Typed + for two Int operands. as_int decode + wrapping_add,
boxing back through NanValue::new_int. Skips the tag-dispatch
chain in arith_add. Emitted when both operand types resolve to
Type::Int.
Append separator only when buffer is non-empty. Pop sep, pop buf →
push buf. No-op for the first append, so the synthesized __buffered
loop body can place the separator before each element uniformly.
Append the bytes of a string to a buffer. Pop str, pop buf →
push buf (same handle). The String pointed to by buf.handle is
mutated in place via String::push_str.
Frameless call to a leaf+thin+args-only function.
No CallFrame is pushed — just saves (fn_id, ip) in the dispatch loop,
sets bp to the args already on stack, and jumps to the target.
On RETURN, restores the caller’s state directly.
Format: fn_id:u16, argc:u8 (same as CALL_KNOWN).
Parallel function calls for independent products (?! / !).
Pops N callable values plus their args from the stack, dispatches them via
the same callable resolution rules as CALL_VALUE, then builds the result tuple.
Enters/exits replay group around parallel dispatch.
Typed == for two Int operands. Skips NanValue::eq_in’s tag
dispatch — as_int_unboxed() on both sides, raw i64 compare, push
bool. Emitted by the VM compiler when both left.ty() and
right.ty() resolve to Type::Int. Hot path in pattern-match-on-
Int (match n { 0 -> …; _ -> … }) and arithmetic guards; profile
shows eq_in at 10–12% self-time in newtype/match scenarios.
Typed < for two Float operands. as_float (raw f64::from_bits)
on both sides, IEEE 754 compare, push bool. Hot in numeric loops
(Mandelbrot inner step match curZ2 > 4.0 { … } etc.); profile
shows compare_lt at 2.6% self-time on fractal_seahorse.
Typed < for two Int operands. as_int decode on both sides
(folds the inline path inline), raw i64 compare, push bool. Skips
compare_lt‘s tag-dispatch (is_int/is_float/is_string chain
plus cross-type promotion). Emitted when both operands’
Spanned::ty() resolve to Type::Int.
Like MATCH_DISPATCH but every entry carries an inline result instead
of a jump offset. When an entry matches, the result is pushed directly
onto the stack and the match body is skipped entirely.
Fused match n { LIT -> ...; _ -> ... } arm test: peek the top of
stack (subject left in place by the surrounding compile_match),
if its Int value equals the inline imm literal — fall through
to the arm body; otherwise skip via fail_offset. Replaces the
DUP + LOAD_CONST + EQ + JUMP_IF_FALSE sequence the generic
compile_pattern emits — one dispatch instead of four in the hot
path of every match n { 0 -> ... } shape.
Push stack[bp + slot] and clear the slot (move semantics).
Used for last-use variables: caller releases sole ownership so
callees and builtins see refcount=1 and can mutate in-place.
Tail-call self for thin frames: no arena finalization needed.
The compiler emits this instead of TAIL_CALL_SELF when the function
is known to be “thin” (no heap allocations within the frame).
Skips finalize_frame_locals_for_tail_call entirely — just copies
args in-place and resets ip.
Inline Option.withDefault: pop default, pop option → push inner or default.
Stack: [option, default] → [result]
If option is Some → push unwrapped inner value.
If option is None → push default.
Inline Result.withDefault: pop default, pop result → push inner or default.
Stack: [result, default] → [value]
If result is Ok → push unwrapped inner value.
If result is Err → push default.