Enum PirOperation 

#[non_exhaustive]
pub enum PirOperation {
    LexicalRead {
        name: LexicalName,
    },
    LexicalWrite {
        name: LexicalName,
    },
    StashRead {
        symbol: SymbolName,
    },
    StashWrite {
        symbol: SymbolName,
    },
    Modify {
        name: LexicalName,
        op: String,
    },
    StashModify {
        symbol: SymbolName,
        op: String,
    },
    Assign,
    Call {
        callee: PirCallee,
        arg_count: usize,
    },
    MethodCall {
        receiver: PirReceiver,
        method: PirMethod,
        arg_count: usize,
    },
    Branch {
        condition: Option<PirId>,
    },
    Loop {
        condition: Option<PirId>,
    },
    Return,
    DynamicBoundary {
        kind: PirDynamicBoundaryKind,
        reason: String,
    },
}

A modeled PIR operation.

Operations model data access, calls, and control flow without executing Perl. Families that the current HIR substrate cannot prove (for example branch and loop conditions, or explicit returns) are part of the contract but are populated by later lowering passes; receipts make the gap visible.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

LexicalRead

Read a lexical variable.

Fields

name: LexicalName

The lexical being read.

LexicalWrite

Write (declare or assign) a lexical variable.

Fields

name: LexicalName

The lexical being written.

StashRead

Read a package/stash symbol.

Fields

symbol: SymbolName

The symbol being read.

StashWrite

Write a package/stash symbol.

Fields

symbol: SymbolName

The symbol being written.

Modify

Compound read-modify-write on a lexical variable (+=, -=, ++, etc.).

The place is evaluated exactly once. The compound operator is preserved in op so downstream analyses can distinguish += from ++ without re-parsing.

Fields

name: LexicalName

The lexical variable being modified.

op: String

The compound operator text ("+=", "-=", "*=", "++", "--", etc.).

StashModify

Compound read-modify-write on a package/stash symbol.

Mirrors Modify for package slots.

Fields

symbol: SymbolName

The package symbol being modified.

op: String

The compound operator text.

Assign

An assignment expression.

Call

A subroutine or function call.

Fields

callee: PirCallee

The callee.

arg_count: usize

Number of parsed arguments.

MethodCall

A method call.

Fields

receiver: PirReceiver

The receiver.

method: PirMethod

The method.

arg_count: usize

Number of parsed arguments.

Branch

A branch (condition is populated by later control-flow lowering).

Fields

condition: Option<PirId>

PIR node computing the branch condition, when modeled.

Loop

A loop (condition is populated by later control-flow lowering).

Fields

condition: Option<PirId>

PIR node computing the loop condition, when modeled.

Return

A return from the enclosing subroutine.

DynamicBoundary

A preserved dynamic boundary.

Fields

kind: PirDynamicBoundaryKind

Boundary category.

reason: String

Short human-readable reason for the boundary.

Implementations

impl PirOperation

pub const ALL_OPERATION_NAMES: &[&'static str]

All operation-family names PIR v0 models.

Receipts and status generators should use this list instead of keeping a separate copy of the current PIR operation surface.

pub const fn name(&self) -> &'static str

Stable operation-family name used in receipts and snapshots.

Trait Implementations

impl Clone for PirOperation

fn clone(&self) -> PirOperation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PirOperation

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

Formats the value using the given formatter.

impl Eq for PirOperation

impl PartialEq for PirOperation

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