Enum ClauseData

pub enum ClauseData {
    Bare(Identifier),
    Expression(Expression),
    ItemList(Vec<ClauseItem>),
    Private {
        items: Vec<ClauseItem>,
    },
    Firstprivate {
        items: Vec<ClauseItem>,
    },
    Lastprivate {
        modifier: Option<LastprivateModifier>,
        items: Vec<ClauseItem>,
    },
    Shared {
        items: Vec<ClauseItem>,
    },
    Default(DefaultKind),
    Reduction {
        operator: ReductionOperator,
        items: Vec<ClauseItem>,
    },
    Map {
        map_type: Option<MapType>,
        mapper: Option<Identifier>,
        items: Vec<ClauseItem>,
    },
    UseDevicePtr {
        items: Vec<ClauseItem>,
    },
    UseDeviceAddr {
        items: Vec<ClauseItem>,
    },
    IsDevicePtr {
        items: Vec<ClauseItem>,
    },
    HasDeviceAddr {
        items: Vec<ClauseItem>,
    },
    Depend {
        depend_type: DependType,
        items: Vec<ClauseItem>,
    },
    Priority {
        priority: Expression,
    },
    Affinity {
        items: Vec<ClauseItem>,
    },
    Schedule {
        kind: ScheduleKind,
        modifiers: Vec<ScheduleModifier>,
        chunk_size: Option<Expression>,
    },
    Collapse {
        n: Expression,
    },
    Ordered {
        n: Option<Expression>,
    },
    Linear {
        modifier: Option<LinearModifier>,
        items: Vec<ClauseItem>,
        step: Option<Expression>,
    },
    Aligned {
        items: Vec<ClauseItem>,
        alignment: Option<Expression>,
    },
    Safelen {
        length: Expression,
    },
    Simdlen {
        length: Expression,
    },
    If {
        directive_name: Option<Identifier>,
        condition: Expression,
    },
    ProcBind(ProcBind),
    NumThreads {
        num: Expression,
    },
    Device {
        device_num: Expression,
    },
    DeviceType(DeviceType),
    AtomicDefaultMemOrder(MemoryOrder),
    AtomicOperation {
        op: AtomicOp,
        memory_order: Option<MemoryOrder>,
    },
    Order(OrderKind),
    NumTeams {
        num: Expression,
    },
    ThreadLimit {
        limit: Expression,
    },
    Allocate {
        allocator: Option<Identifier>,
        items: Vec<ClauseItem>,
    },
    Allocator {
        allocator: Identifier,
    },
    Copyin {
        items: Vec<ClauseItem>,
    },
    Copyprivate {
        items: Vec<ClauseItem>,
    },
    DistSchedule {
        kind: ScheduleKind,
        chunk_size: Option<Expression>,
    },
    Grainsize {
        grain: Expression,
    },
    NumTasks {
        num: Expression,
    },
    Filter {
        thread_num: Expression,
    },
    Generic {
        name: Identifier,
        data: Option<String>,
    },
}

Complete semantic data for an OpenMP clause

This enum represents the meaning of each OpenMP clause type. Each variant captures the specific data needed for that clause.

Examples

// default(shared)
let clause = ClauseData::Default(DefaultKind::Shared);
assert_eq!(clause.to_string(), "default(shared)");

// reduction(+: sum)
let clause = ClauseData::Reduction {
    operator: ReductionOperator::Add,
    items: vec![Identifier::new("sum").into()],
};
assert_eq!(clause.to_string(), "reduction(+: sum)");

Learning: Large Enums with Complex Data

This enum demonstrates several advanced Rust patterns:

1. Many variants: ~30 variants for different clause types
2. Variants with data: Most variants contain structured data
3. Named fields: Using struct-like syntax for clarity
4. Vec for lists: Variable-length lists of items
5. Option for optionals: Optional parameters
6. Composition: Combines all previous IR types

Design Philosophy

Each variant captures exactly what’s needed for semantic analysis:

• Private: List of variables to make private
• Reduction: Operator + list of reduction variables
• Map: Map type + list of variables to map
• Schedule: Schedule kind + optional modifiers + optional chunk size

This is much richer than the parser’s string-based representation.

Variants

Bare(Identifier)

Clause with no parameters (e.g., nowait, nogroup)

Expression(Expression)

Single expression parameter (e.g., num_threads(4))

ItemList(Vec<ClauseItem>)

List of items (e.g., private(x, y, z))

Private

private(list) - Variables are private to each thread

Fields

items: Vec<ClauseItem>

Firstprivate

firstprivate(list) - Variables initialized from master thread

Fields

items: Vec<ClauseItem>

Lastprivate

lastprivate([modifier:] list) - Variables updated from last iteration

Fields

modifier: Option<LastprivateModifier>

items: Vec<ClauseItem>

Shared

shared(list) - Variables shared among all threads

Fields

items: Vec<ClauseItem>

Default(DefaultKind)

default(shared|none|...) - Default data-sharing attribute

Reduction

reduction([modifier,]operator: list) - Reduction operation

Fields

operator: ReductionOperator

items: Vec<ClauseItem>

Map

map([[mapper(id),] map-type:] list) - Map variables to device

Fields

map_type: Option<MapType>

mapper: Option<Identifier>

items: Vec<ClauseItem>

UseDevicePtr

use_device_ptr(list) - Use device pointers

Fields

items: Vec<ClauseItem>

UseDeviceAddr

use_device_addr(list) - Use device addresses

Fields

items: Vec<ClauseItem>

IsDevicePtr

is_device_ptr(list) - Variables are device pointers

Fields

items: Vec<ClauseItem>

HasDeviceAddr

has_device_addr(list) - Variables have device addresses

Fields

items: Vec<ClauseItem>

Depend

depend([modifier,] type: list) - Task dependencies

Fields

depend_type: DependType

items: Vec<ClauseItem>

Priority

priority(expression) - Task priority

Fields

priority: Expression

Affinity

affinity([modifier:] list) - Task affinity

Fields

items: Vec<ClauseItem>

Schedule

schedule([modifier [, modifier]:]kind[, chunk_size]) - Loop schedule

Fields

kind: ScheduleKind

modifiers: Vec<ScheduleModifier>

chunk_size: Option<Expression>

Collapse

collapse(n) - Collapse nested loops

Fields

n: Expression

Ordered

ordered[(n)] - Ordered iterations

Fields

n: Option<Expression>

Linear

linear(list[:step]) - Linear variables in SIMD

Fields

modifier: Option<LinearModifier>

items: Vec<ClauseItem>

step: Option<Expression>

Aligned

aligned(list[:alignment]) - Aligned variables

Fields

items: Vec<ClauseItem>

alignment: Option<Expression>

Safelen

safelen(length) - Safe SIMD vector length

Fields

length: Expression

Simdlen

simdlen(length) - Preferred SIMD vector length

Fields

length: Expression

If

if([directive-name-modifier:] expression) - Conditional execution

Fields

directive_name: Option<Identifier>

condition: Expression

ProcBind(ProcBind)

proc_bind(master|close|spread|primary) - Thread affinity policy

NumThreads

num_threads(expression) - Number of threads

Fields

num: Expression

Device

device(expression) - Target device

Fields

device_num: Expression

DeviceType(DeviceType)

device_type(host|nohost|any) - Device type specifier

AtomicDefaultMemOrder(MemoryOrder)

atomic_default_mem_order(seq_cst|acq_rel|...) - Default memory order

AtomicOperation

Atomic operation modifier

Fields

op: AtomicOp

memory_order: Option<MemoryOrder>

Order(OrderKind)

order(concurrent) - Iteration execution order

NumTeams

num_teams(expression) - Number of teams

Fields

num: Expression

ThreadLimit

thread_limit(expression) - Thread limit per team

Fields

limit: Expression

Allocate

allocate([allocator:] list) - Memory allocator

Fields

allocator: Option<Identifier>

items: Vec<ClauseItem>

Allocator

allocator(allocator-handle) - Specify allocator

Fields

allocator: Identifier

Copyin

copyin(list) - Copy master thread value to team threads

Fields

items: Vec<ClauseItem>

Copyprivate

copyprivate(list) - Broadcast value from one thread

Fields

items: Vec<ClauseItem>

DistSchedule

dist_schedule(kind[, chunk_size]) - Distribute schedule

Fields

kind: ScheduleKind

chunk_size: Option<Expression>

Grainsize

grainsize(expression) - Taskloop grainsize

Fields

grain: Expression

NumTasks

num_tasks(expression) - Number of tasks

Fields

num: Expression

Filter

filter(thread-num) - Thread filter for masked construct

Fields

thread_num: Expression

Generic

Generic clause with unparsed data (fallback for unknown clauses)

Fields

name: Identifier

data: Option<String>

Implementations

impl<'a> ClauseData

pub fn is_default(&self) -> bool

Check if this is a default clause

pub fn is_private(&self) -> bool

Check if this is a private clause

pub fn is_firstprivate(&self) -> bool

Check if this is a firstprivate clause

pub fn is_lastprivate(&self) -> bool

Check if this is a lastprivate clause

pub fn is_shared(&self) -> bool

Check if this is a shared clause

pub fn is_reduction(&self) -> bool

Check if this is a reduction clause

pub fn is_map(&self) -> bool

Check if this is a map clause

pub fn is_if(&self) -> bool

Check if this is an if clause

pub fn is_num_threads(&self) -> bool

Check if this is a num_threads clause

pub fn is_collapse(&self) -> bool

Check if this is a collapse clause

pub fn is_ordered(&self) -> bool

Check if this is an ordered clause

pub fn is_schedule(&self) -> bool

Check if this is a schedule clause

pub fn is_device(&self) -> bool

Check if this is a device clause

pub fn is_depend(&self) -> bool

Check if this is a depend clause

pub fn is_linear(&self) -> bool

Check if this is a linear clause

pub fn is_proc_bind(&self) -> bool

Check if this is a proc_bind clause

Trait Implementations

impl Clone for ClauseData

fn clone(&self) -> ClauseData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ClauseData

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

Formats the value using the given formatter.

impl Display for ClauseData

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

Formats the value using the given formatter.

impl PartialEq for ClauseData

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