Struct PragmaSet 

pub struct PragmaSet {
    pub entries: Vec<Pragma>,
    pub parent: Option<Arc<PragmaSet>>,
}

All pragmas declared in one Polydat scope. Multiple PragmaSets chain through their parent field, set by PragmaSet::attach_to, to model nested scopes (program → for body). Per SRD 13b §“Scope composition” + SRD 15 §“Pragma Scope”: each scope is its own PragmaSet, the chain is walked at lookup time, and outer scopes win on conflict.

Fields

entries: Vec<Pragma>

The pragmas declared in this scope, in order.

parent: Option<Arc<PragmaSet>>

Outer scope, if any. Lookups walk this chain after their own entries miss; conflicts are detected at attach time via PragmaSet::attach_to. The Arc keeps the outer scope cheap to share across many child scopes (e.g. one workload scope feeding a fan-out of phase scopes).

Implementations

impl PragmaSet

pub fn contains(&self, name: &str) -> bool

Returns true if the named pragma is present in this scope or any enclosing scope.

pub fn strict_types(&self) -> bool

Returns true if either strict_types or the strict alias is set in this scope or any enclosing scope.

pub fn strict_values(&self) -> bool

Returns true if either strict_values or the strict alias is set in this scope or any enclosing scope.

pub fn unknown(&self) -> impl Iterator<Item = &Pragma>

Iterate pragmas this scope declares that the compiler doesn’t recognise. Local-only — does not walk parents (the outer scope already reported its own unknowns at its own compile time).

pub fn attach_to( self, outer: Arc<PragmaSet>, ) -> (PragmaSet, Vec<PragmaConflict>)

Attach this PragmaSet to an outer scope, returning (attached, conflicts). Conflicts arise when this scope declares a pragma whose effective value (currently just args) differs from a same-named declaration in the outer chain. Outer wins; the conflict is returned for diagnostic reporting.

The caller decides what to do with conflicts:

• non-strict: emit warning event(s)
• strict: turn each conflict into a compile error

Today’s pragma vocabulary is presence-only so args is always empty; conflicts are degenerate. The framework is in place for future value-bearing pragmas. The compiler does not call this today: a for body inherits a clone of its parent’s set.

Trait Implementations

impl Clone for PragmaSet

fn clone(&self) -> PragmaSet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PragmaSet

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

Formats the value using the given formatter.

impl Default for PragmaSet

fn default() -> PragmaSet

Returns the “default value” for a type.