Syntax

pub struct Instruction {
    pub opcode: OpCode, // 1 byte (with #[repr(u8)] planned)
    pub operand: u16, // 2 bytes
}

Name        -> name() (handles assignment, walrus, calls)
String      -> emit Str constant; concatenate adjacent String tokens
Int / Float -> emit numeric constant; promote to BigInt if oversized
True/False/None/Ellipsis -> emit dedicated load opcode
FstringStart -> fstring()
Lbrace      -> brace_literal()  (dict, set, comprehension)
Lsqb        -> list_literal()   (list, comprehension)
Lpar        -> grouped expr, tuple, generator, or empty tuple
Lambda      -> parse_lambda()

a and b

LoadName a
JumpIfFalseOrPop  ->  end
LoadName b
end:

x = 1 # x_1
x = 2 # x_2
y = x # y_1, references x_2

chunk.names = ["x_1", "x_2", "y_1"]
chunk.instructions:
   LoadConst 0    (1)
   StoreName 0    (x_1)
   LoadConst 1    (2)
   StoreName 1    (x_2)
   LoadName  1    (x_2)
   StoreName 2    (y_1)

enter_block() -> snapshot current versions into JoinNode.backup (and reset to the same baseline for the if branch).
mid_block() -> snapshot post-then versions into JoinNode.then; restore baseline (max of backup, then-state) for else.
commit_block() -> diff (then ∪ post) against (backup), emit Phi for each name that diverged.

if cond:
    x = 1
else:
    x = 2
print(x)

LoadName cond_0
JumpIfFalse else_label
LoadConst 0 *(1)
StoreName x_1
Jump end_label
else_label:
LoadConst 1 *(2)
StoreName x_2
end_label:
Phi x_3 *(sources: x_1, x_2)
LoadName x_3
CallPrint 1

if          -> if_stmt          (with elif chain, optional else)
for         -> for_stmt_inner   (sync iter, optional else)
while       -> while_stmt       (with break/continue patches)
match       -> match_stmt
def         -> func_def_inner
class       -> class_def        (__init__, attributes, methods)
with        -> with_stmt_inner  (multi-target, async variant)
try         -> try_stmt         (except, else, finally, raise)
import      -> import_stmt      (parses; runtime raises)
from        -> parse_from_stmt
type        -> type-alias declaration
yield       -> yield expr / yield from
async       -> async def / for / with
@           -> decorator stack + def
return      -> expr + ReturnValue
raise       -> expr + Raise / RaiseFrom
break       -> patched at loop end
continue    -> jump to current loop_start
del / global / nonlocal / assert / pass -> direct emit
Name        -> name_stmt (assignment, augmented, indexed, attribute, call)

self.with_fresh_chunk(|s| {
    s.ssa_versions = outer_versions.clone();
    for p in &params { s.ssa_versions.insert(p.clone(), 0); }
    s.expr();                        // or compile_block_body for def
    s.chunk.emit(OpCode::ReturnValue, 0);
});

counter: int = 0       # annotation 'int' parsed and stored, slot still gets 0
def f(x: int) -> int:  # annotations on params and return parsed and skipped
    return x

f"hello {name}, age {age}"

LoadConst "hello "
LoadName  name_v
FormatValue 0
LoadConst ", age "
LoadName  age_v
FormatValue 0
BuildString 5