Struct MatchIR 

pub struct MatchIR {
    pub label: Label,
    pub nav: Nav,
    pub node_type: NodeTypeIR,
    pub node_field: Option<NonZeroU16>,
    pub pre_effects: Vec<EffectIR>,
    pub neg_fields: Vec<u16>,
    pub post_effects: Vec<EffectIR>,
    pub predicate: Option<PredicateIR>,
    pub successors: Vec<Label>,
}

Match instruction IR with symbolic successors.

Fields

label: Label

Where this instruction lives.

nav: Nav

Navigation command. Epsilon means pure control flow (no node check).

node_type: NodeTypeIR

Node type constraint (Any = wildcard, Named/Anonymous for specific checks).

node_field: Option<NonZeroU16>

Field constraint (None = wildcard).

pre_effects: Vec<EffectIR>

Effects to execute before match attempt.

neg_fields: Vec<u16>

Fields that must NOT be present on the node.

post_effects: Vec<EffectIR>

Effects to execute after successful match.

predicate: Option<PredicateIR>

Predicate for node text filtering (None = no text check).

successors: Vec<Label>

Successor labels (empty = accept, 1 = linear, 2+ = branch).

Implementations

impl MatchIR

pub fn terminal(label: Label) -> Self

Create a terminal/accept state (empty successors).

pub fn at(label: Label) -> Self

Start building a match instruction at the given label.

pub fn epsilon(label: Label, next: Label) -> Self

Create an epsilon transition (no node interaction) to a single successor.

pub fn nav(self, nav: Nav) -> Self

Set the navigation command.

pub fn node_type(self, t: NodeTypeIR) -> Self

Set the node type constraint.

pub fn node_field(self, f: impl Into<Option<NonZeroU16>>) -> Self

Set the field constraint.

pub fn neg_field(self, f: u16) -> Self

Add a negated field constraint.

pub fn pre_effect(self, e: EffectIR) -> Self

Add a pre-match effect.

pub fn post_effect(self, e: EffectIR) -> Self

Add a post-match effect.

pub fn neg_fields(self, fields: impl IntoIterator<Item = u16>) -> Self

Add multiple negated field constraints.

pub fn pre_effects(self, effects: impl IntoIterator<Item = EffectIR>) -> Self

Add multiple pre-match effects.

pub fn post_effects(self, effects: impl IntoIterator<Item = EffectIR>) -> Self

Add multiple post-match effects.

pub fn predicate(self, p: PredicateIR) -> Self

Set the predicate for node text filtering.

pub fn next(self, s: Label) -> Self

Set a single successor.

pub fn next_many(self, s: Vec<Label>) -> Self

Set multiple successors (for branches).

pub fn size(&self) -> usize

Compute instruction size in bytes.

pub fn resolve<F, G, R>( &self, map: &BTreeMap<Label, StepAddr>, lookup_member: F, get_member_base: G, lookup_regex: R, ) -> Vec<u8>

where F: Fn(Symbol, TypeId) -> Option<u16>, G: Fn(TypeId) -> Option<u16>, R: Fn(StringId) -> Option<u16>,

Resolve labels and serialize to bytecode bytes.

• lookup_member: maps (field_name Symbol, field_type TypeId) to member index
• get_member_base: maps parent TypeId to member base index
• lookup_regex: maps pattern to RegexTable index (for predicate regexes)

pub fn is_epsilon(&self) -> bool

Check if this is an epsilon transition (no node interaction).

Trait Implementations

impl Clone for MatchIR

fn clone(&self) -> MatchIR

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MatchIR

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

Formats the value using the given formatter.

impl From<MatchIR> for InstructionIR

fn from(m: MatchIR) -> Self

Converts to this type from the input type.