Enum Instruction 

pub enum Instruction {
    Span(u32, u32, u32),
    Label,
    FunctionStart,
    FunctionEnd,
    Breakpoint,
    Branch(u32),
    ConditionalBranch(u32, u32),
    Return(u32),
    IndirectCall,
    Call(u32, u32),
    Halt,
    Print,
    Load(Type, u32),
    Store(Type, u32),
    Dup,
    HeapAlloc(u32),
    GetItem,
    HeapDealloc,
    Const(Value),
    Add(Type),
    Sub(Type),
    Mul(Type),
    Div(Type),
    Rem(Type),
    Neg(Type),
    Shl(Type),
    Shr(Type),
    Rol(Type),
    Ror(Type),
    BitAnd(Type),
    BitOr(Type),
    BitXor(Type),
    Not,
    And,
    Or,
    Xor,
    Eq(Type),
    Ne(Type),
    Lt(Type),
    Gt(Type),
    Le(Type),
    Ge(Type),
}

#[derive(Parse)] notes:

• Real .sst syntax uses dot-suffixed types (add.i64, load.i64 0). The parse_helpers::cpu_type / cpu_const_value helpers consume the leading .; that’s why the typed variants set delimiters(open = "", close = "", separator = "") and use #[parse_with] on the Type field.
• Const(Value::String/FunctionRef/HeapRef), Branch(_), ConditionalBranch(_, _), Call(_, _), and bare ret use symbolic operands that need a shared interner / symbol table not available to a stateless Parse impl. Their parse_with helpers return never_u32 so Instruction::parser() errors on those mnemonics — the Module orchestrator (Item 4 of the migration plan) intercepts them first.
• Variant order is preserved from the pre-migration layout so derived opcodes stay stable. The single exception: IndirectCall is moved ahead of Call so the prefix-ordering check (call ⊂ call_indirect) passes.

Variants

Span(u32, u32, u32)

span file:file_id start:u32 end:u32 span 0 1 2 — three space-separated u32s.

Label

Label definition.

FunctionStart

func_start <name> — marks function entry. <name> is symbolic and orchestrator-resolved; the unit variant carries no payload.

FunctionEnd

func_end <name> — marks function exit (debug only).

Breakpoint

breakpoint. Must precede Branch (whose token br would be a prefix of breakpoint).

Branch(u32)

br <target> — symbolic. Deferred to orchestrator.

ConditionalBranch(u32, u32)

cond_br <true_target>, <false_target> — symbolic. Deferred.

Return(u32)

ret (bare) is the form real .sst uses; numeric ret <n> has no precedent so we defer. Orchestrator emits Return(0) for bare ret.

IndirectCall

call_indirect. Must precede Call for the prefix check.

Call(u32, u32)

call <arity>, <addr> — symbolic addr. Deferred.

Halt

halt — stop execution.

Print

print — write top-of-stack to stdout.

Load(Type, u32)

load.<type> <address> — two fields with single-space separator.

Store(Type, u32)

store.<type> <address>.

Dup

dup.

HeapAlloc(u32)

heap_alloc <n>.

GetItem

get_item. Must precede Ge (token ge ⊂ get_item).

HeapDealloc

heap_dealloc — pops a HeapRef and marks the slot dead, returning it to the free list for reuse by the next heap_alloc.

Const(Value)

const.<type> <literal> — numeric/bool only here. .str/.fn_ref/ .heap_ref are orchestrator-handled.

Add(Type)

Sub(Type)

Mul(Type)

Div(Type)

Rem(Type)

Neg(Type)

Shl(Type)

Shr(Type)

Rol(Type)

Ror(Type)

BitAnd(Type)

BitOr(Type)

BitXor(Type)

Not

And

Or

Xor

Eq(Type)

Ne(Type)

Lt(Type)

Gt(Type)

Le(Type)

Ge(Type)

Trait Implementations

impl CanonicalInstructionSyntax for Instruction

fn variants() -> &'static [CanonicalInstructionVariantSyntax]

impl Clone for Instruction

fn clone(&self) -> Instruction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Instruction

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

Formats the value using the given formatter.

impl Display for Instruction

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

Formats the value using the given formatter.

impl<T: Into<Value>> From<T> for Instruction

fn from(value: T) -> Self

Converts to this type from the input type.

impl FromBytesWithOpcode for Instruction

fn from_bytes_with_opcode<R: Read>(bytes: &mut R, opcode: u8) -> Result<Self>

impl OpCode for Instruction

fn width() -> u32

fn opcode(&self) -> u8

impl<'src> Parse<'src> for Instruction

fn parser() -> impl Parser<'src, &'src str, Self, Err<Simple<'src, char>>>

impl PartialEq for Instruction

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

fn write_bytes<W: Write>(&self, io: &mut W) -> Result<()>

impl StructuralPartialEq for Instruction