stryke/

compiler.rs

use std::collections::{HashMap, HashSet};

use crate::ast::*;
use crate::bytecode::{
    BuiltinId, Chunk, Op, RuntimeAdviceDecl, RuntimeSubDecl, GP_CHECK, GP_END, GP_INIT, GP_RUN,
    GP_START,
};
use crate::sort_fast::detect_sort_block_fast;
use crate::value::PerlValue;
use crate::vm_helper::{assign_rhs_wantarray, VMHelper, WantarrayCtx};

/// True when EXPR as the *tail* of a `map { … }` block would produce a different value in
/// list context than in scalar context — Range (flip-flop vs list), comma lists, `reverse` /
/// `sort` / `map` / `grep` calls, array/hash variables and derefs, `@{...}`, etc. Shared
/// block-bytecode regions compile the tail in scalar context for grep/sort, so map VM paths
/// consult this predicate to decide whether to reuse the shared region or emit a
/// list-tail [`Interpreter::exec_block_with_tail`](crate::vm_helper::VMHelper::exec_block_with_tail) call.
pub fn expr_tail_is_list_sensitive(expr: &Expr) -> bool {
    match &expr.kind {
        // Range `..` in scalar context is flip-flop, in list context is expansion.
        ExprKind::Range { .. } | ExprKind::SliceRange { .. } => true,
        // Multi-element list: `($a, $b)` returns 2 values in list, last in scalar.
        ExprKind::List(items) => items.len() != 1 || expr_tail_is_list_sensitive(&items[0]),
        ExprKind::QW(ws) => ws.len() != 1,
        // Deref of array/hash: `@$ref` / `%$ref`.
        ExprKind::Deref {
            kind: Sigil::Array | Sigil::Hash,
            ..
        } => true,
        // Slices always produce lists.
        ExprKind::ArraySlice { .. }
        | ExprKind::HashSlice { .. }
        | ExprKind::HashSliceDeref { .. }
        | ExprKind::AnonymousListSlice { .. } => true,
        // Map/grep/sort blocks need list-context tail evaluation.
        ExprKind::MapExpr { .. }
        | ExprKind::MapExprComma { .. }
        | ExprKind::GrepExpr { .. }
        | ExprKind::SortExpr { .. } => true,
        // FuncCalls that return lists in list context, scalars in scalar context.
        ExprKind::FuncCall { name, .. } => matches!(
            name.as_str(),
            "wantarray"
                | "reverse"
                | "sort"
                | "map"
                | "grep"
                | "keys"
                | "values"
                | "each"
                | "split"
                | "caller"
                | "localtime"
                | "gmtime"
                | "stat"
                | "lstat"
        ),
        ExprKind::Ternary {
            then_expr,
            else_expr,
            ..
        } => expr_tail_is_list_sensitive(then_expr) || expr_tail_is_list_sensitive(else_expr),
        // ArrayVar, HashVar, slices — handled by VM's ReturnValue + List context
        // compilation. Do NOT allow these to trigger a compilation error.
        _ => false,
    }
}

/// True when one `{…}` entry expands to multiple hash keys (`qw/a b/`, a list literal with 2+
/// elems, or a list-context `..` range like `'a'..'c'`).
pub(crate) fn hash_slice_key_expr_is_multi_key(k: &Expr) -> bool {
    match &k.kind {
        ExprKind::QW(ws) => ws.len() > 1,
        ExprKind::List(el) => el.len() > 1,
        ExprKind::Range { .. } | ExprKind::SliceRange { .. } => true,
        _ => false,
    }
}

/// Use [`Op::HashSliceDeref`] / [`Op::HashSliceDerefCompound`] / [`Op::HashSliceDerefIncDec`], or
/// [`Op::NamedHashSliceCompound`] / [`Op::NamedHashSliceIncDec`] for stash `@h{…}`, instead of arrow-hash single-slot ops.
pub(crate) fn hash_slice_needs_slice_ops(keys: &[Expr]) -> bool {
    keys.len() != 1 || keys.first().is_some_and(hash_slice_key_expr_is_multi_key)
}

/// `$r->[EXPR] //=` / `||=` / `&&=` — the bytecode fast path uses [`Op::ArrowArray`] (scalar index).
/// Range / multi-word `qw`/list subscripts need different semantics; not yet lowered to bytecode.
/// `$r->[IX]` reads/writes via [`Op::ArrowArray`] only when `IX` is a **plain scalar** subscript.
/// `..` / `qw/.../` / `(a,b)` / nested lists always go through slice ops (flattened index specs).
pub(crate) fn arrow_deref_arrow_subscript_is_plain_scalar_index(index: &Expr) -> bool {
    match &index.kind {
        ExprKind::Range { .. } | ExprKind::SliceRange { .. } => false,
        ExprKind::QW(_) => false,
        ExprKind::List(el) => {
            if el.len() == 1 {
                arrow_deref_arrow_subscript_is_plain_scalar_index(&el[0])
            } else {
                false
            }
        }
        _ => !hash_slice_key_expr_is_multi_key(index),
    }
}

/// Compilation error — halts compilation with an error.
#[derive(Debug)]
pub enum CompileError {
    Unsupported(String),
    /// Immutable binding reassignment (e.g. `frozen my $x` then `$x = 1`).
    Frozen {
        line: usize,
        detail: String,
    },
}

#[derive(Default, Clone)]
struct ScopeLayer {
    declared_scalars: HashSet<String>,
    /// Bare names from `our $x` — rvalue/lvalue ops must use the package stash key (`main::x`).
    declared_our_scalars: HashSet<String>,
    declared_arrays: HashSet<String>,
    declared_hashes: HashSet<String>,
    frozen_scalars: HashSet<String>,
    frozen_arrays: HashSet<String>,
    frozen_hashes: HashSet<String>,
    /// Slot-index mapping for `my` scalars in compiled subroutines.
    /// When `use_slots` is true, `my $x` is assigned a u8 slot index
    /// and the VM accesses it via `GetScalarSlot(idx)` — O(1).
    scalar_slots: HashMap<String, u8>,
    next_scalar_slot: u8,
    /// True when compiling a subroutine body (enables slot assignment).
    use_slots: bool,
    /// `mysync @name` — element `++`/`--`/compound assign not yet lowered to bytecode (atomic RMW).
    mysync_arrays: HashSet<String>,
    /// `mysync %name` — same as [`Self::mysync_arrays`].
    mysync_hashes: HashSet<String>,
    /// `mysync $name` — opt-in shared closure capture (Arc-cell). Closures may
    /// freely mutate these; default `my` scalars trigger a compile-time error
    /// if a closure writes to them from inside a sub body. (DESIGN-001)
    mysync_scalars: HashSet<String>,
    /// True when this layer was entered for an anonymous-or-named sub body
    /// (`sub { ... }` / `fn { ... }` / `sub foo { ... }`). Used by the
    /// closure-write check to detect when a write crosses a sub-body
    /// boundary (DESIGN-001). False for `map`/`grep`/`sort` block layers
    /// (those are not closures in the value-snapshot sense).
    is_sub_body: bool,
}

/// Loop context for resolving `last`/`next` jumps.
///
/// Pushed onto [`Compiler::loop_stack`] at every loop entry so `last`/`next` (including those
/// nested inside `if`/`unless`/`{ }` blocks) can find the matching loop and patch their jumps.
///
/// `entry_frame_depth` is [`Compiler::frame_depth`] at loop entry — `last`/`next` from inside
/// emits `(frame_depth - entry_frame_depth)` `Op::PopFrame` instructions before jumping so any
/// `if`/block-pushed scope frames are torn down.
///
/// `entry_try_depth` mirrors `try { }` nesting; if a `last`/`next` would have to cross a try
/// frame the compiler bails to `Unsupported` (try-frame unwind on flow control is not yet
/// modeled in bytecode — the catch handler would still see the next exception).
struct LoopCtx {
    label: Option<String>,
    entry_frame_depth: usize,
    entry_try_depth: usize,
    /// First bytecode IP of the loop **body** (after `while`/`until` condition, after `for` condition,
    /// after `foreach` assigns `$var` from the list, or `do` body start) — target for `redo`.
    body_start_ip: usize,
    /// Positions of `last`/`next` jumps to patch after the loop body is fully compiled.
    break_jumps: Vec<usize>,
    /// `Op::Jump(0)` placeholders for `next` — patched to the loop increment / condition entry.
    continue_jumps: Vec<usize>,
}

pub struct Compiler {
    pub chunk: Chunk,
    /// During compilation: stable [`Expr`] pointer → [`Chunk::ast_expr_pool`] index.
    ast_expr_intern: HashMap<usize, u32>,
    pub begin_blocks: Vec<Block>,
    pub unit_check_blocks: Vec<Block>,
    pub check_blocks: Vec<Block>,
    pub init_blocks: Vec<Block>,
    pub end_blocks: Vec<Block>,
    /// Lexical `my` declarations per scope frame (mirrors `PushFrame` / sub bodies).
    scope_stack: Vec<ScopeLayer>,
    /// Current `package` for stash qualification (`@ISA`, `@EXPORT`, …), matching [`VMHelper::stash_array_name_for_package`].
    current_package: String,
    /// Set while compiling the main program body when the last statement must leave its value on the
    /// stack (implicit return). Enables `try`/`catch` blocks to match `emit_block_value` semantics.
    program_last_stmt_takes_value: bool,
    /// Source path for `__FILE__` in bytecode (must match the interpreter's notion of current file when using the VM).
    pub source_file: String,
    /// Runtime activation depth — `Op::PushFrame` count minus `Op::PopFrame` count emitted so far.
    /// Used by `last`/`next` to compute how many frames to pop before jumping.
    frame_depth: usize,
    /// `try { }` nesting depth — `last`/`next` cannot currently cross a try-frame in bytecode.
    try_depth: usize,
    /// Active loops, innermost at the back. `last`/`next` consult this stack.
    loop_stack: Vec<LoopCtx>,
    /// Per-function (top-level program or sub body) `goto LABEL` tracking. Top of the stack holds
    /// the label→IP map and forward-goto patch list for the innermost enclosing label-scoped
    /// region. `goto` is only resolved against the top frame (matches Perl's "goto must target a
    /// label in the same lexical context" intuition).
    goto_ctx_stack: Vec<GotoCtx>,
    /// `use strict 'vars'` — reject access to undeclared globals at compile time (mirrors
    /// `Interpreter::check_strict_*_var` runtime checks). Set via
    /// [`Self::with_strict_vars`] before `compile_program` runs; stable throughout a single
    /// compile because `use strict` is resolved in `prepare_program_top_level` before the VM
    /// compile begins.
    strict_vars: bool,
    /// True while compiling a deferred sort/reduce block in the 4th pass. `$a` and `$b`
    /// inside such blocks must use name-based access — `set_sort_pair` writes by name,
    /// so a slot allocation from any outer `my $a`/`my $b` (which the deferred pass sees
    /// because it runs after the whole program is compiled) would silently miss the
    /// per-iteration value. Other variables continue to use slots so outer `my`
    /// captures remain O(1).
    force_name_for_sort_pair: bool,
    /// Block indices registered via [`Self::register_sort_pair_block`] — sort/reduce
    /// comparator bodies that bind `$a`/`$b` magic globals. The deferred 4th pass
    /// turns on [`Self::force_name_for_sort_pair`] only for these blocks.
    sort_pair_block_indices: std::collections::HashSet<u16>,
    /// Block indices that came from an anonymous-or-named sub-body
    /// (`sub { ... }` / `fn { ... }`). The 4th-pass compile pushes a
    /// `is_sub_body: true` scope layer before compiling these so the
    /// closure-write check (DESIGN-001) can detect outer-scope `my`
    /// writes. Map/grep/sort blocks are NOT in this set.
    sub_body_block_indices: std::collections::HashSet<u16>,
    /// Per-block signature params (parallel to `chunk.blocks`) used by the
    /// 4th-pass compile to register CodeRef params in the new sub-body
    /// scope layer.
    code_ref_block_params: Vec<Vec<crate::ast::SubSigParam>>,
    /// Snapshot of `scope_stack` taken when each block was added. The 4th pass
    /// (`compile_program`) defers map/grep/sort block compilation until after
    /// every sub body has finished, by which point the parent scope_stack has
    /// already been popped. Without these snapshots, references like the
    /// fn-local `my $max` inside `map { … $max … }` would resolve against the
    /// trailing top-level scope_stack and silently bind to a sibling top-level
    /// `my $max` slot. The 4th pass swaps the matching snapshot in before
    /// compiling each block. Index lines up with `chunk.blocks`; entries are
    /// `None` for blocks added through code paths that don't go through the
    /// compiler's [`Self::add_deferred_block`] wrapper.
    block_scope_snapshots: Vec<Option<Vec<ScopeLayer>>>,
}

/// Label tracking for `goto LABEL` within a single label-scoped region (top-level main program
/// or subroutine body). See [`Compiler::enter_goto_scope`] / [`Compiler::exit_goto_scope`].
#[derive(Default)]
struct GotoCtx {
    /// `label_name → (bytecode IP of the labeled statement's first op, frame_depth at label)`
    labels: HashMap<String, (usize, usize)>,
    /// `(jump_op_ip, label_name, source_line, frame_depth_at_goto)` for forward `goto LABEL`.
    pending: Vec<(usize, String, usize, usize)>,
}

impl Default for Compiler {
    fn default() -> Self {
        Self::new()
    }
}

impl Compiler {
    /// Array/hash slice subscripts are list context: `@a[LIST]` flattens ranges, `reverse`,
    /// `sort`, `grep`, `map`, and array variables the same way `@h{LIST}` does. Scalar
    /// subscripts are unaffected because list context on a plain scalar is still the scalar.
    fn compile_array_slice_index_expr(&mut self, index_expr: &Expr) -> Result<(), CompileError> {
        self.compile_expr_ctx(index_expr, WantarrayCtx::List)
    }

    /// Hash-slice key component: `'a'..'c'` inside `@h{...}` / `@$h{...}` is a list-context
    /// range so the VM's hash-slice helpers receive an array to flatten into individual keys.
    fn compile_hash_slice_key_expr(&mut self, key_expr: &Expr) -> Result<(), CompileError> {
        if matches!(
            &key_expr.kind,
            ExprKind::Range { .. } | ExprKind::SliceRange { .. }
        ) {
            self.compile_expr_ctx(key_expr, WantarrayCtx::List)
        } else {
            self.compile_expr(key_expr)
        }
    }

    /// Push the value of `expr` if present, or `Undef` (the omitted-endpoint sentinel
    /// used by [`Op::ArraySliceRange`] / [`Op::HashSliceRange`]) if `None`.
    fn compile_optional_or_undef(&mut self, expr: Option<&Expr>) -> Result<(), CompileError> {
        match expr {
            Some(e) => self.compile_expr(e),
            None => {
                self.emit_op(Op::LoadUndef, 0, None);
                Ok(())
            }
        }
    }

    pub fn new() -> Self {
        Self {
            chunk: Chunk::new(),
            ast_expr_intern: HashMap::new(),
            begin_blocks: Vec::new(),
            unit_check_blocks: Vec::new(),
            check_blocks: Vec::new(),
            init_blocks: Vec::new(),
            end_blocks: Vec::new(),
            // Main program `my $x` uses [`Op::GetScalarSlot`] / [`Op::SetScalarSlot`] like subs,
            // so hot loops are not stuck on [`Op::GetScalarPlain`] (linear scan per access).
            scope_stack: vec![ScopeLayer {
                use_slots: true,
                ..Default::default()
            }],
            current_package: String::new(),
            program_last_stmt_takes_value: false,
            source_file: String::new(),
            frame_depth: 0,
            try_depth: 0,
            loop_stack: Vec::new(),
            goto_ctx_stack: Vec::new(),
            strict_vars: false,
            force_name_for_sort_pair: false,
            sort_pair_block_indices: std::collections::HashSet::new(),
            sub_body_block_indices: std::collections::HashSet::new(),
            code_ref_block_params: Vec::new(),
            block_scope_snapshots: Vec::new(),
        }
    }

    /// Add a deferred-compilation block (map/grep/sort/reduce/…) to the chunk
    /// AND snapshot the current `scope_stack` so the 4th pass can compile the
    /// block under the lexical scope it was originally defined in. Replaces
    /// every former `self.add_deferred_block(…)` call site inside the compiler so
    /// no block slips through unsnapshotted. See [`Self::block_scope_snapshots`].
    fn add_deferred_block(&mut self, block: Block) -> u16 {
        let idx = self.chunk.add_block(block);
        let snap = self.scope_stack.clone();
        while self.block_scope_snapshots.len() < idx as usize {
            self.block_scope_snapshots.push(None);
        }
        self.block_scope_snapshots.push(Some(snap));
        idx
    }

    /// Mark a block index as a sort/reduce comparator that binds `$a`/`$b`.
    /// The deferred 4th pass enables [`Self::force_name_for_sort_pair`] before
    /// compiling registered indices so `$a`/`$b` references resolve via name
    /// instead of any outer `my` slot allocation.
    fn register_sort_pair_block(&mut self, idx: u16) {
        self.sort_pair_block_indices.insert(idx);
    }

    /// Set `use strict 'vars'` at compile time. When enabled, [`compile_expr`] rejects any read
    /// or write of an undeclared global scalar / array / hash with `CompileError::Frozen` — the
    /// same diagnostic emitted at runtime (`Global symbol "$name" requires
    /// explicit package name`). `try_vm_execute` pulls the flag from `Interpreter::strict_vars`
    /// before constructing the compiler, matching the timing of
    /// `prepare_program_top_level` (which processes `use strict` before main body execution).
    pub fn with_strict_vars(mut self, v: bool) -> Self {
        self.strict_vars = v;
        self
    }

    /// Enter a `goto LABEL` scope (called when compiling the top-level main program or a sub
    /// body). Labels defined inside can be targeted from any `goto` inside the same scope;
    /// labels are *not* shared across nested functions.
    fn enter_goto_scope(&mut self) {
        self.goto_ctx_stack.push(GotoCtx::default());
    }

    /// Resolve all pending forward gotos and pop the scope. Returns `CompileError::Frozen` if a
    /// `goto` targets a label that was never defined in this scope (same diagnostic as
    /// runtime: `goto: unknown label NAME`). Returns `Unsupported` if a
    /// `goto` crosses a frame boundary (e.g. from inside an `if` body out to an outer label) —
    /// crossing frames would skip `PopFrame` ops and corrupt the scope stack. That case is
    /// not yet lowered to bytecode.
    fn exit_goto_scope(&mut self) -> Result<(), CompileError> {
        let ctx = self
            .goto_ctx_stack
            .pop()
            .expect("exit_goto_scope called without matching enter");
        for (jump_ip, label, line, goto_frame_depth) in ctx.pending {
            if let Some(&(target_ip, label_frame_depth)) = ctx.labels.get(&label) {
                if label_frame_depth != goto_frame_depth {
                    return Err(CompileError::Unsupported(format!(
                        "goto LABEL crosses a scope frame (label `{}` at depth {} vs goto at depth {})",
                        label, label_frame_depth, goto_frame_depth
                    )));
                }
                self.chunk.patch_jump_to(jump_ip, target_ip);
            } else {
                return Err(CompileError::Frozen {
                    line,
                    detail: format!("goto: unknown label {}", label),
                });
            }
        }
        Ok(())
    }

    /// Record `label → current IP` if a goto-scope is active. Called before each labeled
    /// statement is emitted; the label points to the first op of the statement.
    fn record_stmt_label(&mut self, label: &str) {
        if let Some(top) = self.goto_ctx_stack.last_mut() {
            top.labels
                .insert(label.to_string(), (self.chunk.len(), self.frame_depth));
        }
    }

    /// If `target` is a compile-time-known label name (bareword or literal string), emit a
    /// forward `Jump(0)` and record it for patching on goto-scope exit. Returns `true` if the
    /// goto was handled (so the caller should not emit a fallback). Returns `false` if the target
    /// is dynamic — the caller should bail to `CompileError::Unsupported` so the tree path can
    /// still handle it in future.
    fn try_emit_goto_label(&mut self, target: &Expr, line: usize) -> bool {
        let name = match &target.kind {
            ExprKind::Bareword(n) => n.clone(),
            ExprKind::String(s) => s.clone(),
            // Parser may produce a zero-arg FuncCall for a bare label name
            ExprKind::FuncCall { name, args } if args.is_empty() => name.clone(),
            _ => return false,
        };
        if self.goto_ctx_stack.is_empty() {
            return false;
        }
        let jump_ip = self.chunk.emit(Op::Jump(0), line);
        let frame_depth = self.frame_depth;
        self.goto_ctx_stack
            .last_mut()
            .expect("goto scope must be active")
            .pending
            .push((jump_ip, name, line, frame_depth));
        true
    }

    /// Emit `Op::PushFrame` and bump [`Self::frame_depth`].
    fn emit_push_frame(&mut self, line: usize) {
        self.chunk.emit(Op::PushFrame, line);
        self.frame_depth += 1;
    }

    /// Emit `Op::PopFrame` and decrement [`Self::frame_depth`] (saturating).
    fn emit_pop_frame(&mut self, line: usize) {
        self.chunk.emit(Op::PopFrame, line);
        self.frame_depth = self.frame_depth.saturating_sub(1);
    }

    pub fn with_source_file(mut self, path: String) -> Self {
        self.source_file = path;
        self
    }

    /// `@ISA` / `@EXPORT` / `@EXPORT_OK` outside `main` → `Pkg::NAME` (see interpreter stash rules).
    fn qualify_stash_array_name(&self, name: &str) -> String {
        if matches!(name, "ISA" | "EXPORT" | "EXPORT_OK") {
            let pkg = &self.current_package;
            if !pkg.is_empty() && pkg != "main" {
                return format!("{}::{}", pkg, name);
            }
        }
        name.to_string()
    }

    /// Package stash key for `our $name` (matches [`VMHelper::stash_scalar_name_for_package`]).
    fn qualify_stash_scalar_name(&self, name: &str) -> String {
        if name.contains("::") {
            return name.to_string();
        }
        let pkg = &self.current_package;
        if pkg.is_empty() || pkg == "main" {
            format!("main::{}", name)
        } else {
            format!("{}::{}", pkg, name)
        }
    }

    /// Runtime name for `$x` in bytecode after `my`/`our` resolution (`our` → qualified stash).
    fn scalar_storage_name_for_ops(&self, bare: &str) -> String {
        if bare.contains("::") {
            return bare.to_string();
        }
        for layer in self.scope_stack.iter().rev() {
            if layer.declared_scalars.contains(bare) {
                if layer.declared_our_scalars.contains(bare) {
                    return self.qualify_stash_scalar_name(bare);
                }
                return bare.to_string();
            }
        }
        bare.to_string()
    }

    #[inline]
    fn intern_scalar_var_for_ops(&mut self, bare: &str) -> u16 {
        let s = self.scalar_storage_name_for_ops(bare);
        self.chunk.intern_name(&s)
    }

    /// For `local $x`, qualify to package stash since local only works on package variables.
    /// Special vars (like `$/`, `$\`, `$,`, `$"`, or `^X` caret vars) are not qualified.
    fn intern_scalar_for_local(&mut self, bare: &str) -> u16 {
        if VMHelper::is_special_scalar_name_for_set(bare) || bare.starts_with('^') {
            self.chunk.intern_name(bare)
        } else {
            let s = self.qualify_stash_scalar_name(bare);
            self.chunk.intern_name(&s)
        }
    }

    fn register_declare_our_scalar(&mut self, bare_name: &str) {
        let layer = self.scope_stack.last_mut().expect("scope stack");
        layer.declared_scalars.insert(bare_name.to_string());
        layer.declared_our_scalars.insert(bare_name.to_string());
    }

    /// `our $x` — package stash binding; no slot indices (bare `$x` maps to `main::x` / `Pkg::x`).
    fn emit_declare_our_scalar(&mut self, bare_name: &str, line: usize, frozen: bool) {
        let stash = self.qualify_stash_scalar_name(bare_name);
        let stash_idx = self.chunk.intern_name(&stash);
        self.register_declare_our_scalar(bare_name);
        if frozen {
            self.chunk.emit(Op::DeclareScalarFrozen(stash_idx), line);
        } else {
            self.chunk.emit(Op::DeclareScalar(stash_idx), line);
        }
    }

    /// Stash key for a subroutine name in the current package (matches [`VMHelper::qualify_sub_key`]).
    fn qualify_sub_key(&self, name: &str) -> String {
        if name.contains("::") {
            return name.to_string();
        }
        let pkg = &self.current_package;
        if pkg.is_empty() || pkg == "main" {
            name.to_string()
        } else {
            format!("{}::{}", pkg, name)
        }
    }

    /// First-pass sub registration: walk `package` statements like [`Self::compile_program`] does for
    /// sub bodies so forward `sub` entries use the same stash key as runtime registration.
    fn qualify_sub_decl_pass1(name: &str, pending_pkg: &str) -> String {
        if name.contains("::") {
            return name.to_string();
        }
        if pending_pkg.is_empty() || pending_pkg == "main" {
            name.to_string()
        } else {
            format!("{}::{}", pending_pkg, name)
        }
    }

    /// After all `sub` bodies are lowered, replace [`Op::Call`] with [`Op::CallStaticSubId`] when the
    /// callee has a compiled entry (avoids linear `sub_entries` scan + extra stash work per call).
    fn patch_static_sub_calls(chunk: &mut Chunk) {
        for i in 0..chunk.ops.len() {
            if let Op::Call(name_idx, argc, wa) = chunk.ops[i] {
                if let Some((entry_ip, stack_args)) = chunk.find_sub_entry(name_idx) {
                    if chunk.static_sub_calls.len() < u16::MAX as usize {
                        let sid = chunk.static_sub_calls.len() as u16;
                        chunk
                            .static_sub_calls
                            .push((entry_ip, stack_args, name_idx));
                        chunk.ops[i] = Op::CallStaticSubId(sid, name_idx, argc, wa);
                    }
                }
            }
        }
    }

    /// For `$aref->[ix]` / `@$r[ix]` arrow-array ops: the stack must hold the **array reference**
    /// (scalar), not `@{...}` / `@$r` expansion (which would push a cloned plain array).
    fn compile_arrow_array_base_expr(&mut self, expr: &Expr) -> Result<(), CompileError> {
        if let ExprKind::Deref {
            expr: inner,
            kind: Sigil::Array | Sigil::Scalar,
        } = &expr.kind
        {
            self.compile_expr(inner)
        } else {
            self.compile_expr(expr)
        }
    }

    /// For `$href->{k}` / `$$r{k}`: stack holds the hash **reference** scalar, not a copied `%` value.
    fn compile_arrow_hash_base_expr(&mut self, expr: &Expr) -> Result<(), CompileError> {
        if let ExprKind::Deref {
            expr: inner,
            kind: Sigil::Scalar,
        } = &expr.kind
        {
            self.compile_expr(inner)
        } else {
            self.compile_expr(expr)
        }
    }

    fn push_scope_layer(&mut self) {
        self.scope_stack.push(ScopeLayer::default());
    }

    /// Push a scope layer with slot assignment enabled (for subroutine bodies).
    fn push_scope_layer_with_slots(&mut self) {
        self.scope_stack.push(ScopeLayer {
            use_slots: true,
            is_sub_body: true,
            ..Default::default()
        });
    }

    /// Register a signature parameter (`fn foo($x, @args, %opts) { ... }`) in
    /// the current scope layer so the closure-write check (DESIGN-001)
    /// recognises writes to the param as local — not outer-scope `my`.
    fn register_sig_param(&mut self, p: &crate::ast::SubSigParam) {
        use crate::ast::SubSigParam;
        let layer = self.scope_stack.last_mut().expect("scope stack");
        match p {
            SubSigParam::Scalar(name, _, _) => {
                layer.declared_scalars.insert(name.clone());
            }
            SubSigParam::Array(name, _) => {
                layer.declared_arrays.insert(name.clone());
            }
            SubSigParam::Hash(name, _) => {
                layer.declared_hashes.insert(name.clone());
            }
            SubSigParam::ArrayDestruct(elems) => {
                for el in elems {
                    match el {
                        crate::ast::MatchArrayElem::CaptureScalar(n) => {
                            layer.declared_scalars.insert(n.clone());
                        }
                        crate::ast::MatchArrayElem::RestBind(n) => {
                            layer.declared_arrays.insert(n.clone());
                        }
                        _ => {}
                    }
                }
            }
            SubSigParam::HashDestruct(pairs) => {
                for (_, var) in pairs {
                    layer.declared_scalars.insert(var.clone());
                }
            }
        }
    }

    fn pop_scope_layer(&mut self) {
        if self.scope_stack.len() > 1 {
            self.scope_stack.pop();
        }
    }

    /// Look up a scalar's slot index in the current scope layer (if slots are enabled).
    fn scalar_slot(&self, name: &str) -> Option<u8> {
        // Deferred sort-block compilation: `$a`/`$b` must be name-based so the
        // runtime `set_sort_pair` (which writes by name) and the comparator's
        // reads agree. Slot allocation from any outer `my $a`/`my $b` is
        // visible here because the 4th pass runs after the whole program is
        // compiled. See [`Self::force_name_for_sort_pair`].
        if self.force_name_for_sort_pair && (name == "a" || name == "b") {
            return None;
        }
        if let Some(layer) = self.scope_stack.last() {
            if layer.use_slots {
                return layer.scalar_slots.get(name).copied();
            }
        }
        None
    }

    /// Intern an [`Expr`] for [`Chunk::op_ast_expr`] (pointer-stable during compile).
    fn intern_ast_expr(&mut self, expr: &Expr) -> u32 {
        let p = expr as *const Expr as usize;
        if let Some(&id) = self.ast_expr_intern.get(&p) {
            return id;
        }
        let id = self.chunk.ast_expr_pool.len() as u32;
        self.chunk.ast_expr_pool.push(expr.clone());
        self.ast_expr_intern.insert(p, id);
        id
    }

    /// Emit one opcode with optional link to the originating expression (expression compiler path).
    #[inline]
    fn emit_op(&mut self, op: Op, line: usize, ast: Option<&Expr>) -> usize {
        let idx = ast.map(|e| self.intern_ast_expr(e));
        self.chunk.emit_with_ast_idx(op, line, idx)
    }

    /// Emit GetScalar or GetScalarSlot depending on whether the variable has a slot.
    fn emit_get_scalar(&mut self, name_idx: u16, line: usize, ast: Option<&Expr>) {
        let name = &self.chunk.names[name_idx as usize];
        if let Some(slot) = self.scalar_slot(name) {
            self.emit_op(Op::GetScalarSlot(slot), line, ast);
        } else if VMHelper::is_special_scalar_name_for_get(name) {
            self.emit_op(Op::GetScalar(name_idx), line, ast);
        } else {
            self.emit_op(Op::GetScalarPlain(name_idx), line, ast);
        }
    }

    /// Boolean rvalue: bare `/.../` is `$_ =~ /.../` (Perl), not “regex object is truthy”.
    /// Emits `$_` + pattern and [`Op::RegexMatchDyn`] so match vars and truthy 0/1 match `=~`.
    fn compile_boolean_rvalue_condition(&mut self, cond: &Expr) -> Result<(), CompileError> {
        let line = cond.line;
        if let ExprKind::Regex(pattern, flags) = &cond.kind {
            let name_idx = self.chunk.intern_name("_");
            self.emit_get_scalar(name_idx, line, Some(cond));
            let pat_idx = self.chunk.add_constant(PerlValue::string(pattern.clone()));
            let flags_idx = self.chunk.add_constant(PerlValue::string(flags.clone()));
            self.emit_op(Op::LoadRegex(pat_idx, flags_idx), line, Some(cond));
            self.emit_op(Op::RegexMatchDyn(false), line, Some(cond));
            Ok(())
        } else if matches!(&cond.kind, ExprKind::ReadLine(_)) {
            // `while (<STDIN>)` — assign line to `$_` then test definedness (Perl).
            self.compile_expr(cond)?;
            let name_idx = self.chunk.intern_name("_");
            self.emit_set_scalar_keep(name_idx, line, Some(cond));
            self.emit_op(
                Op::CallBuiltin(BuiltinId::Defined as u16, 1),
                line,
                Some(cond),
            );
            Ok(())
        } else {
            self.compile_expr(cond)
        }
    }

    /// Emit SetScalar or SetScalarSlot depending on slot availability.
    fn emit_set_scalar(&mut self, name_idx: u16, line: usize, ast: Option<&Expr>) {
        let name = &self.chunk.names[name_idx as usize];
        if let Some(slot) = self.scalar_slot(name) {
            self.emit_op(Op::SetScalarSlot(slot), line, ast);
        } else if VMHelper::is_special_scalar_name_for_set(name) {
            self.emit_op(Op::SetScalar(name_idx), line, ast);
        } else {
            self.emit_op(Op::SetScalarPlain(name_idx), line, ast);
        }
    }

    /// Emit SetScalarKeep or SetScalarSlotKeep depending on slot availability.
    fn emit_set_scalar_keep(&mut self, name_idx: u16, line: usize, ast: Option<&Expr>) {
        let name = &self.chunk.names[name_idx as usize];
        if let Some(slot) = self.scalar_slot(name) {
            self.emit_op(Op::SetScalarSlotKeep(slot), line, ast);
        } else if VMHelper::is_special_scalar_name_for_set(name) {
            self.emit_op(Op::SetScalarKeep(name_idx), line, ast);
        } else {
            self.emit_op(Op::SetScalarKeepPlain(name_idx), line, ast);
        }
    }

    fn emit_pre_inc(&mut self, name_idx: u16, line: usize, ast: Option<&Expr>) {
        let name = &self.chunk.names[name_idx as usize];
        if let Some(slot) = self.scalar_slot(name) {
            self.emit_op(Op::PreIncSlot(slot), line, ast);
        } else {
            self.emit_op(Op::PreInc(name_idx), line, ast);
        }
    }

    fn emit_pre_dec(&mut self, name_idx: u16, line: usize, ast: Option<&Expr>) {
        let name = &self.chunk.names[name_idx as usize];
        if let Some(slot) = self.scalar_slot(name) {
            self.emit_op(Op::PreDecSlot(slot), line, ast);
        } else {
            self.emit_op(Op::PreDec(name_idx), line, ast);
        }
    }

    fn emit_post_inc(&mut self, name_idx: u16, line: usize, ast: Option<&Expr>) {
        let name = &self.chunk.names[name_idx as usize];
        if let Some(slot) = self.scalar_slot(name) {
            self.emit_op(Op::PostIncSlot(slot), line, ast);
        } else {
            self.emit_op(Op::PostInc(name_idx), line, ast);
        }
    }

    fn emit_post_dec(&mut self, name_idx: u16, line: usize, ast: Option<&Expr>) {
        let name = &self.chunk.names[name_idx as usize];
        if let Some(slot) = self.scalar_slot(name) {
            self.emit_op(Op::PostDecSlot(slot), line, ast);
        } else {
            self.emit_op(Op::PostDec(name_idx), line, ast);
        }
    }

    /// Assign a new slot index for a scalar in the current scope layer.
    /// Returns the slot index if slots are enabled, None otherwise.
    fn assign_scalar_slot(&mut self, name: &str) -> Option<u8> {
        if let Some(layer) = self.scope_stack.last_mut() {
            if layer.use_slots && layer.next_scalar_slot < 255 {
                let slot = layer.next_scalar_slot;
                layer.scalar_slots.insert(name.to_string(), slot);
                layer.next_scalar_slot += 1;
                return Some(slot);
            }
        }
        None
    }

    fn register_declare(&mut self, sigil: Sigil, name: &str, frozen: bool) {
        let layer = self.scope_stack.last_mut().expect("scope stack");
        match sigil {
            Sigil::Scalar => {
                layer.declared_scalars.insert(name.to_string());
                if frozen {
                    layer.frozen_scalars.insert(name.to_string());
                }
            }
            Sigil::Array => {
                layer.declared_arrays.insert(name.to_string());
                if frozen {
                    layer.frozen_arrays.insert(name.to_string());
                }
            }
            Sigil::Hash => {
                layer.declared_hashes.insert(name.to_string());
                if frozen {
                    layer.frozen_hashes.insert(name.to_string());
                }
            }
            Sigil::Typeglob => {
                layer.declared_scalars.insert(name.to_string());
            }
        }
    }

    /// `use strict 'vars'` check for a scalar `$name`. Mirrors [`VMHelper::check_strict_scalar_var`]:
    /// ok if strict is off, the name contains `::` (package-qualified), the name is a Perl special
    /// scalar, or the name is declared via `my`/`our` in any enclosing compiler scope layer.
    /// Otherwise errors with the exact diagnostic message so the user sees a consistent
    /// error from the VM.
    fn check_strict_scalar_access(&self, name: &str, line: usize) -> Result<(), CompileError> {
        if !self.strict_vars
            || name.contains("::")
            || VMHelper::strict_scalar_exempt(name)
            || VMHelper::is_special_scalar_name_for_get(name)
            || self
                .scope_stack
                .iter()
                .any(|l| l.declared_scalars.contains(name))
        {
            return Ok(());
        }
        Err(CompileError::Frozen {
            line,
            detail: format!(
                "Global symbol \"${}\" requires explicit package name (did you forget to declare \"my ${}\"?)",
                name, name
            ),
        })
    }

    /// Array names that are always bound at runtime (Perl built-ins) and must not trigger a
    /// `use strict 'vars'` compile error even though they're never `my`-declared.
    fn strict_array_exempt(name: &str) -> bool {
        matches!(
            name,
            "_" | "ARGV" | "INC" | "ENV" | "ISA" | "EXPORT" | "EXPORT_OK" | "EXPORT_FAIL"
        )
    }

    /// Hash names that are always bound at runtime.
    fn strict_hash_exempt(name: &str) -> bool {
        matches!(
            name,
            "ENV" | "INC" | "SIG" | "EXPORT_TAGS" | "ISA" | "OVERLOAD" | "+" | "-" | "!" | "^H"
        )
    }

    fn check_strict_array_access(&self, name: &str, line: usize) -> Result<(), CompileError> {
        if !self.strict_vars
            || name.contains("::")
            || Self::strict_array_exempt(name)
            || self
                .scope_stack
                .iter()
                .any(|l| l.declared_arrays.contains(name))
        {
            return Ok(());
        }
        Err(CompileError::Frozen {
            line,
            detail: format!(
                "Global symbol \"@{}\" requires explicit package name (did you forget to declare \"my @{}\"?)",
                name, name
            ),
        })
    }

    fn check_strict_hash_access(&self, name: &str, line: usize) -> Result<(), CompileError> {
        if !self.strict_vars
            || name.contains("::")
            || Self::strict_hash_exempt(name)
            || self
                .scope_stack
                .iter()
                .any(|l| l.declared_hashes.contains(name))
        {
            return Ok(());
        }
        Err(CompileError::Frozen {
            line,
            detail: format!(
                "Global symbol \"%{}\" requires explicit package name (did you forget to declare \"my %{}\"?)",
                name, name
            ),
        })
    }

    fn check_scalar_mutable(&self, name: &str, line: usize) -> Result<(), CompileError> {
        for layer in self.scope_stack.iter().rev() {
            if layer.declared_scalars.contains(name) {
                if layer.frozen_scalars.contains(name) {
                    return Err(CompileError::Frozen {
                        line,
                        detail: format!("cannot assign to frozen variable `${}`", name),
                    });
                }
                return Ok(());
            }
        }
        Ok(())
    }

    /// Closure-write rule (DESIGN-001): writing to an outer-scope `my $x`
    /// from inside a sub body silently mutates only the closure's snapshot
    /// — the outer scope keeps its own value, which is almost always a
    /// bug. Reject at compile time and point the user at `mysync $x` (for
    /// shared mutable state) or `--compat` (for Perl 5 shared semantics).
    ///
    /// Returns Ok(()) when:
    ///   - `name` is declared in the innermost sub-body layer (locally owned).
    ///   - `name` is `mysync` (atomic shared cell — safe to mutate).
    ///   - `name` is `our` (package global — explicitly cross-scope state).
    ///   - `--compat` mode is active (Perl 5 shared-storage semantics).
    ///   - `name` is undeclared (caught by strict-vars elsewhere).
    fn check_closure_write_to_outer_my(&self, name: &str, line: usize) -> Result<(), CompileError> {
        if crate::compat_mode() {
            return Ok(());
        }
        // Walk innermost-first. Look for the boundary: any layer between us
        // and the declaring layer that is a sub body (`is_sub_body`) means
        // the variable was declared outside the closure we're currently in.
        let mut crossed_sub_body = false;
        for layer in self.scope_stack.iter().rev() {
            if layer.declared_scalars.contains(name) {
                if !crossed_sub_body {
                    return Ok(());
                }
                if layer.mysync_scalars.contains(name) {
                    return Ok(());
                }
                if layer.declared_our_scalars.contains(name) {
                    return Ok(());
                }
                return Err(CompileError::Frozen {
                    line,
                    detail: format!(
                        "cannot modify outer-scope `my ${name}` from inside a closure — \
                         stryke closures capture by value to keep parallel dispatch race-free. \
                         Use `mysync ${name}` for shared mutable state, or `--compat` for Perl 5 \
                         shared-storage semantics"
                    ),
                });
            }
            if layer.is_sub_body {
                crossed_sub_body = true;
            }
        }
        Ok(())
    }

    fn check_array_mutable(&self, name: &str, line: usize) -> Result<(), CompileError> {
        for layer in self.scope_stack.iter().rev() {
            if layer.declared_arrays.contains(name) {
                if layer.frozen_arrays.contains(name) {
                    return Err(CompileError::Frozen {
                        line,
                        detail: format!("cannot modify frozen array `@{}`", name),
                    });
                }
                return Ok(());
            }
        }
        Ok(())
    }

    fn check_hash_mutable(&self, name: &str, line: usize) -> Result<(), CompileError> {
        for layer in self.scope_stack.iter().rev() {
            if layer.declared_hashes.contains(name) {
                if layer.frozen_hashes.contains(name) {
                    return Err(CompileError::Frozen {
                        line,
                        detail: format!("cannot modify frozen hash `%{}`", name),
                    });
                }
                return Ok(());
            }
        }
        Ok(())
    }

    /// Register variables declared by `use Env qw(@PATH $HOME ...)` so the strict-vars
    /// compiler pass knows they exist.
    fn register_env_imports(layer: &mut ScopeLayer, imports: &[Expr]) {
        for e in imports {
            let mut names_owned: Vec<String> = Vec::new();
            match &e.kind {
                ExprKind::String(s) => names_owned.push(s.clone()),
                ExprKind::QW(ws) => names_owned.extend(ws.iter().cloned()),
                ExprKind::InterpolatedString(parts) => {
                    let mut s = String::new();
                    for p in parts {
                        match p {
                            StringPart::Literal(l) => s.push_str(l),
                            StringPart::ScalarVar(v) => {
                                s.push('$');
                                s.push_str(v);
                            }
                            StringPart::ArrayVar(v) => {
                                s.push('@');
                                s.push_str(v);
                            }
                            _ => continue,
                        }
                    }
                    names_owned.push(s);
                }
                _ => continue,
            };
            for raw in &names_owned {
                if let Some(arr) = raw.strip_prefix('@') {
                    layer.declared_arrays.insert(arr.to_string());
                } else if let Some(hash) = raw.strip_prefix('%') {
                    layer.declared_hashes.insert(hash.to_string());
                } else {
                    let scalar = raw.strip_prefix('$').unwrap_or(raw);
                    layer.declared_scalars.insert(scalar.to_string());
                }
            }
        }
    }

    /// Emit an `Op::RuntimeErrorConst` that matches Perl's
    /// `Can't modify {array,hash} dereference in {pre,post}{increment,decrement} (++|--)` message.
    /// Used for `++@{…}`, `%{…}--`, `@$r++`, etc. — constructs that are invalid in Perl 5.
    /// Pushes `LoadUndef` afterwards so the rvalue position has a value on the stack for any
    /// surrounding `Pop` from statement-expression dispatch (the error op aborts the VM before
    /// the `LoadUndef` is reached, but it keeps the emitted sequence well-formed for stack tracking).
    fn emit_aggregate_symbolic_inc_dec_error(
        &mut self,
        kind: Sigil,
        is_pre: bool,
        is_inc: bool,
        line: usize,
        root: &Expr,
    ) -> Result<(), CompileError> {
        let agg = match kind {
            Sigil::Array => "array",
            Sigil::Hash => "hash",
            _ => {
                return Err(CompileError::Unsupported(
                    "internal: non-aggregate sigil passed to symbolic ++/-- error emitter".into(),
                ));
            }
        };
        let op_str = match (is_pre, is_inc) {
            (true, true) => "preincrement (++)",
            (true, false) => "predecrement (--)",
            (false, true) => "postincrement (++)",
            (false, false) => "postdecrement (--)",
        };
        let msg = format!("Can't modify {} dereference in {}", agg, op_str);
        let idx = self.chunk.add_constant(PerlValue::string(msg));
        self.emit_op(Op::RuntimeErrorConst(idx), line, Some(root));
        // The op never returns; this LoadUndef is dead code but keeps any unreachable
        // `Pop` / rvalue consumer emitted by the enclosing dispatch well-formed.
        self.emit_op(Op::LoadUndef, line, Some(root));
        Ok(())
    }

    /// `mysync @arr` / `mysync %h` — aggregate element updates use `atomic_*_mutate`, not yet lowered to bytecode.
    fn is_mysync_array(&self, array_name: &str) -> bool {
        let q = self.qualify_stash_array_name(array_name);
        self.scope_stack
            .iter()
            .rev()
            .any(|l| l.mysync_arrays.contains(&q))
    }

    fn is_mysync_hash(&self, hash_name: &str) -> bool {
        self.scope_stack
            .iter()
            .rev()
            .any(|l| l.mysync_hashes.contains(hash_name))
    }

    pub fn compile_program(mut self, program: &Program) -> Result<Chunk, CompileError> {
        // Extract BEGIN/END blocks before compiling.
        for stmt in &program.statements {
            match &stmt.kind {
                StmtKind::Begin(block) => self.begin_blocks.push(block.clone()),
                StmtKind::UnitCheck(block) => self.unit_check_blocks.push(block.clone()),
                StmtKind::Check(block) => self.check_blocks.push(block.clone()),
                StmtKind::Init(block) => self.init_blocks.push(block.clone()),
                StmtKind::End(block) => self.end_blocks.push(block.clone()),
                _ => {}
            }
        }

        // First pass: register sub names for forward calls (qualified stash keys, same as runtime).
        let mut pending_pkg = String::new();
        for stmt in &program.statements {
            match &stmt.kind {
                StmtKind::Package { name } => pending_pkg = name.clone(),
                StmtKind::SubDecl { name, .. } => {
                    let q = Self::qualify_sub_decl_pass1(name, &pending_pkg);
                    let name_idx = self.chunk.intern_name(&q);
                    self.chunk.sub_entries.push((name_idx, 0, false));
                }
                _ => {}
            }
        }

        // Second pass: compile main body.
        // The last expression statement keeps its value on the stack so the
        // caller can read the program's return value (like Perl's implicit return).
        let main_stmts: Vec<&Statement> = program
            .statements
            .iter()
            .filter(|s| {
                !matches!(
                    s.kind,
                    StmtKind::SubDecl { .. }
                        | StmtKind::Begin(_)
                        | StmtKind::UnitCheck(_)
                        | StmtKind::Check(_)
                        | StmtKind::Init(_)
                        | StmtKind::End(_)
                )
            })
            .collect();
        let last_idx = main_stmts.len().saturating_sub(1);
        self.program_last_stmt_takes_value = main_stmts
            .last()
            .map(|s| matches!(s.kind, StmtKind::TryCatch { .. }))
            .unwrap_or(false);
        // BEGIN blocks run before main (same order as Perl phase blocks).
        if !self.begin_blocks.is_empty() {
            self.chunk.emit(Op::SetGlobalPhase(GP_START), 0);
        }
        for block in &self.begin_blocks.clone() {
            self.compile_block(block)?;
        }
        // Perl: `${^GLOBAL_PHASE}` stays **`START`** during UNITCHECK blocks.
        let unit_check_rev: Vec<Block> = self.unit_check_blocks.iter().rev().cloned().collect();
        for block in unit_check_rev {
            self.compile_block(&block)?;
        }
        if !self.check_blocks.is_empty() {
            self.chunk.emit(Op::SetGlobalPhase(GP_CHECK), 0);
        }
        let check_rev: Vec<Block> = self.check_blocks.iter().rev().cloned().collect();
        for block in check_rev {
            self.compile_block(&block)?;
        }
        if !self.init_blocks.is_empty() {
            self.chunk.emit(Op::SetGlobalPhase(GP_INIT), 0);
        }
        let inits = self.init_blocks.clone();
        for block in inits {
            self.compile_block(&block)?;
        }
        self.chunk.emit(Op::SetGlobalPhase(GP_RUN), 0);
        // Record where the main body starts — used by `-n`/`-p` to re-execute only the body per line.
        self.chunk.body_start_ip = self.chunk.ops.len();

        // Top-level `goto LABEL` scope: labels defined on main-program statements are targetable
        // from `goto` statements in the same main program. Pushed before the main loop and
        // resolved after it (but before END blocks, which run in their own scope).
        self.enter_goto_scope();

        let mut i = 0;
        while i < main_stmts.len() {
            let stmt = main_stmts[i];
            if i == last_idx {
                // The specialized `last statement leaves its value on the stack` path bypasses
                // `compile_statement` for Expression/If/Unless shapes, so we must record any
                // `LABEL:` on this statement manually before emitting its ops.
                if let Some(lbl) = &stmt.label {
                    self.record_stmt_label(lbl);
                }
                match &stmt.kind {
                    StmtKind::Expression(expr) => {
                        // Last statement of program: still not a regex *value* — bare `/pat/` matches `$_`.
                        if matches!(&expr.kind, ExprKind::Regex(..)) {
                            self.compile_boolean_rvalue_condition(expr)?;
                        } else {
                            self.compile_expr(expr)?;
                        }
                    }
                    StmtKind::If {
                        condition,
                        body,
                        elsifs,
                        else_block,
                    } => {
                        self.compile_boolean_rvalue_condition(condition)?;
                        let j0 = self.chunk.emit(Op::JumpIfFalse(0), stmt.line);
                        self.emit_block_value(body, stmt.line)?;
                        let mut ends = vec![self.chunk.emit(Op::Jump(0), stmt.line)];
                        self.chunk.patch_jump_here(j0);
                        for (c, blk) in elsifs {
                            self.compile_boolean_rvalue_condition(c)?;
                            let j = self.chunk.emit(Op::JumpIfFalse(0), c.line);
                            self.emit_block_value(blk, c.line)?;
                            ends.push(self.chunk.emit(Op::Jump(0), c.line));
                            self.chunk.patch_jump_here(j);
                        }
                        if let Some(eb) = else_block {
                            self.emit_block_value(eb, stmt.line)?;
                        } else {
                            self.chunk.emit(Op::LoadUndef, stmt.line);
                        }
                        for j in ends {
                            self.chunk.patch_jump_here(j);
                        }
                    }
                    StmtKind::Unless {
                        condition,
                        body,
                        else_block,
                    } => {
                        self.compile_boolean_rvalue_condition(condition)?;
                        let j0 = self.chunk.emit(Op::JumpIfFalse(0), stmt.line);
                        if let Some(eb) = else_block {
                            self.emit_block_value(eb, stmt.line)?;
                        } else {
                            self.chunk.emit(Op::LoadUndef, stmt.line);
                        }
                        let end = self.chunk.emit(Op::Jump(0), stmt.line);
                        self.chunk.patch_jump_here(j0);
                        self.emit_block_value(body, stmt.line)?;
                        self.chunk.patch_jump_here(end);
                    }
                    StmtKind::Block(block) => {
                        self.chunk.emit(Op::PushFrame, stmt.line);
                        self.emit_block_value(block, stmt.line)?;
                        self.chunk.emit(Op::PopFrame, stmt.line);
                    }
                    StmtKind::StmtGroup(block) => {
                        self.emit_block_value(block, stmt.line)?;
                    }
                    _ => self.compile_statement(stmt)?,
                }
            } else {
                self.compile_statement(stmt)?;
            }
            i += 1;
        }
        self.program_last_stmt_takes_value = false;

        // Resolve all forward `goto LABEL` against labels recorded in the main scope.
        self.exit_goto_scope()?;

        // END blocks run after main, before halt (same order as Perl phase blocks).
        if !self.end_blocks.is_empty() {
            self.chunk.emit(Op::SetGlobalPhase(GP_END), 0);
        }
        for block in &self.end_blocks.clone() {
            self.compile_block(block)?;
        }

        self.chunk.emit(Op::Halt, 0);

        // Third pass: compile sub bodies after Halt
        let mut entries: Vec<(String, Vec<Statement>, String, Vec<crate::ast::SubSigParam>)> =
            Vec::new();
        let mut pending_pkg = String::new();
        for stmt in &program.statements {
            match &stmt.kind {
                StmtKind::Package { name } => pending_pkg = name.clone(),
                StmtKind::SubDecl {
                    name, body, params, ..
                } => {
                    entries.push((
                        name.clone(),
                        body.clone(),
                        pending_pkg.clone(),
                        params.clone(),
                    ));
                }
                _ => {}
            }
        }

        for (name, body, sub_pkg, params) in &entries {
            let saved_pkg = self.current_package.clone();
            self.current_package = sub_pkg.clone();
            self.push_scope_layer_with_slots();
            // Register signature parameters in the new scope layer so the
            // closure-write check (DESIGN-001) recognises writes to params
            // as local — not outer-scope `my`. Without this, mutating a
            // sub parameter inside a `for` block (or any nested
            // statement-block) would falsely trigger the closure-write
            // diagnostic.
            for p in params {
                self.register_sig_param(p);
            }
            let entry_ip = self.chunk.len();
            let q = self.qualify_sub_key(name);
            let name_idx = self.chunk.intern_name(&q);
            // Patch the entry point
            for e in &mut self.chunk.sub_entries {
                if e.0 == name_idx {
                    e.1 = entry_ip;
                }
            }
            // Each sub body gets its own `goto LABEL` scope: labels are not visible across
            // different subs or between a sub and the main program.
            self.enter_goto_scope();
            // Compile sub body (VM `Call` pushes a scope frame; mirror for frozen tracking).
            self.emit_subroutine_body_return(body)?;
            self.exit_goto_scope()?;
            self.pop_scope_layer();

            // Peephole: convert leading `ShiftArray("_")` to `GetArg(n)` if @_ is
            // not referenced by any other op in this sub. This eliminates Vec
            // allocation + string-based @_ lookup on every call.
            let underscore_idx = self.chunk.intern_name("_");
            self.peephole_stack_args(name_idx, entry_ip, underscore_idx);
            self.current_package = saved_pkg;
        }

        // Fourth pass: lower simple map/grep/sort block bodies to bytecode (after subs; same `ops` vec).
        // Each block was added via [`Self::add_deferred_block`], which captured a
        // snapshot of `scope_stack` at definition time. Swap that snapshot in
        // before compiling so references resolve against the LEXICAL scope the
        // block was written in, not the trailing top-level scope_stack that
        // exists once every sub body has been compiled and popped. Without
        // this, a sub-local `my $max` referenced inside a `map { … $max … }`
        // would silently resolve to a sibling top-level `my $max` slot.
        self.chunk.block_bytecode_ranges = vec![None; self.chunk.blocks.len()];
        for i in 0..self.chunk.blocks.len() {
            let b = self.chunk.blocks[i].clone();
            if Self::block_has_return(&b) {
                continue;
            }
            let saved_scope_stack = self
                .block_scope_snapshots
                .get(i)
                .cloned()
                .flatten()
                .map(|snap| std::mem::replace(&mut self.scope_stack, snap));
            // Sort/reduce blocks bind `$a`/`$b` via [`Scope::set_sort_pair`] (name-write).
            // Suppress slot resolution for those names while compiling the body so that
            // any outer `my $a`/`my $b` slot binding doesn't shadow the per-iter values.
            let is_sort_pair = self.sort_pair_block_indices.contains(&(i as u16));
            self.force_name_for_sort_pair = is_sort_pair;
            // Sub-body blocks (`sub { ... }` / `fn { ... }`): push a fresh
            // `is_sub_body: true` layer so the closure-write check
            // (DESIGN-001) can flag outer-scope `my` writes from inside the
            // body. Map/grep/sort blocks don't push this layer — they share
            // the enclosing scope normally.
            let pushed_sub_body = self.sub_body_block_indices.contains(&(i as u16));
            if pushed_sub_body {
                self.scope_stack.push(ScopeLayer {
                    use_slots: true,
                    is_sub_body: true,
                    ..Default::default()
                });
                // Register the closure's signature params in the new layer
                // so the closure-write check sees them as locally declared.
                if let Some(params) = self.code_ref_block_params.get(i).cloned() {
                    for p in &params {
                        self.register_sig_param(p);
                    }
                }
            }
            let result = self.try_compile_block_region(&b);
            self.force_name_for_sort_pair = false;
            if pushed_sub_body {
                self.scope_stack.pop();
            }
            match result {
                Ok(range) => {
                    self.chunk.block_bytecode_ranges[i] = Some(range);
                }
                Err(CompileError::Frozen { .. }) => {
                    // Real error (e.g. closure-write to outer-`my`,
                    // assignment to `frozen` binding). Restore scope and
                    // propagate.
                    if let Some(orig) = saved_scope_stack {
                        self.scope_stack = orig;
                    }
                    return Err(result.unwrap_err());
                }
                Err(CompileError::Unsupported(_)) => {
                    // Block lowering not yet supported — leave the
                    // bytecode_ranges entry as None; runtime will fall
                    // back to AST execution of the block body.
                }
            }
            if let Some(orig) = saved_scope_stack {
                self.scope_stack = orig;
            }
        }

        // Fifth pass: `map EXPR, LIST` — list-context expression per `$_` (same `ops` vec as blocks).
        self.chunk.map_expr_bytecode_ranges = vec![None; self.chunk.map_expr_entries.len()];
        for i in 0..self.chunk.map_expr_entries.len() {
            let e = self.chunk.map_expr_entries[i].clone();
            if let Ok(range) = self.try_compile_grep_expr_region(&e, WantarrayCtx::List) {
                self.chunk.map_expr_bytecode_ranges[i] = Some(range);
            }
        }

        // Fifth pass (a): `grep EXPR, LIST` — single-expression filter bodies (same `ops` vec as blocks).
        self.chunk.grep_expr_bytecode_ranges = vec![None; self.chunk.grep_expr_entries.len()];
        for i in 0..self.chunk.grep_expr_entries.len() {
            let e = self.chunk.grep_expr_entries[i].clone();
            if let Ok(range) = self.try_compile_grep_expr_region(&e, WantarrayCtx::Scalar) {
                self.chunk.grep_expr_bytecode_ranges[i] = Some(range);
            }
        }

        // Fifth pass (b): regex flip-flop compound RHS — boolean context (same `ops` vec).
        self.chunk.regex_flip_flop_rhs_expr_bytecode_ranges =
            vec![None; self.chunk.regex_flip_flop_rhs_expr_entries.len()];
        for i in 0..self.chunk.regex_flip_flop_rhs_expr_entries.len() {
            let e = self.chunk.regex_flip_flop_rhs_expr_entries[i].clone();
            if let Ok(range) = self.try_compile_flip_flop_rhs_expr_region(&e) {
                self.chunk.regex_flip_flop_rhs_expr_bytecode_ranges[i] = Some(range);
            }
        }

        // Sixth pass: `eval_timeout EXPR { ... }` — timeout expression only (body stays interpreter).
        self.chunk.eval_timeout_expr_bytecode_ranges =
            vec![None; self.chunk.eval_timeout_entries.len()];
        for i in 0..self.chunk.eval_timeout_entries.len() {
            let timeout_expr = self.chunk.eval_timeout_entries[i].0.clone();
            if let Ok(range) =
                self.try_compile_grep_expr_region(&timeout_expr, WantarrayCtx::Scalar)
            {
                self.chunk.eval_timeout_expr_bytecode_ranges[i] = Some(range);
            }
        }

        // Seventh pass: `keys EXPR` / `values EXPR` — operand expression only.
        self.chunk.keys_expr_bytecode_ranges = vec![None; self.chunk.keys_expr_entries.len()];
        for i in 0..self.chunk.keys_expr_entries.len() {
            let e = self.chunk.keys_expr_entries[i].clone();
            if let Ok(range) = self.try_compile_grep_expr_region(&e, WantarrayCtx::List) {
                self.chunk.keys_expr_bytecode_ranges[i] = Some(range);
            }
        }
        self.chunk.values_expr_bytecode_ranges = vec![None; self.chunk.values_expr_entries.len()];
        for i in 0..self.chunk.values_expr_entries.len() {
            let e = self.chunk.values_expr_entries[i].clone();
            if let Ok(range) = self.try_compile_grep_expr_region(&e, WantarrayCtx::List) {
                self.chunk.values_expr_bytecode_ranges[i] = Some(range);
            }
        }

        // Eighth pass: `given (TOPIC) { ... }` — topic expression only.
        self.chunk.given_topic_bytecode_ranges = vec![None; self.chunk.given_entries.len()];
        for i in 0..self.chunk.given_entries.len() {
            let topic = self.chunk.given_entries[i].0.clone();
            if let Ok(range) = self.try_compile_grep_expr_region(&topic, WantarrayCtx::Scalar) {
                self.chunk.given_topic_bytecode_ranges[i] = Some(range);
            }
        }

        // Ninth pass: algebraic `match (SUBJECT) { ... }` — subject expression only.
        self.chunk.algebraic_match_subject_bytecode_ranges =
            vec![None; self.chunk.algebraic_match_entries.len()];
        for i in 0..self.chunk.algebraic_match_entries.len() {
            let subject = self.chunk.algebraic_match_entries[i].0.clone();
            let range: Option<(usize, usize)> = match &subject.kind {
                ExprKind::ArrayVar(name) => {
                    self.check_strict_array_access(name, subject.line)?;
                    let line = subject.line;
                    let start = self.chunk.len();
                    let idx = self.chunk.intern_name(&self.qualify_stash_array_name(name));
                    self.chunk.emit(Op::MakeArrayBindingRef(idx), line);
                    self.chunk.emit(Op::BlockReturnValue, line);
                    Some((start, self.chunk.len()))
                }
                ExprKind::HashVar(name) => {
                    self.check_strict_hash_access(name, subject.line)?;
                    let line = subject.line;
                    let start = self.chunk.len();
                    let idx = self.chunk.intern_name(name);
                    self.chunk.emit(Op::MakeHashBindingRef(idx), line);
                    self.chunk.emit(Op::BlockReturnValue, line);
                    Some((start, self.chunk.len()))
                }
                _ => self
                    .try_compile_grep_expr_region(&subject, WantarrayCtx::Scalar)
                    .ok(),
            };
            self.chunk.algebraic_match_subject_bytecode_ranges[i] = range;
        }

        Self::patch_static_sub_calls(&mut self.chunk);
        self.chunk.peephole_fuse();

        Ok(self.chunk)
    }

    /// Lower a block body to `ops` ending in [`Op::BlockReturnValue`] when possible.
    ///
    /// Matches `Interpreter::exec_block_no_scope` for blocks **without** `return`: last statement
    /// must be [`StmtKind::Expression`] (the value is that expression). Earlier statements use
    /// [`Self::compile_statement`] (void context). Any `CompileError` keeps AST fallback.
    fn try_compile_block_region(&mut self, block: &Block) -> Result<(usize, usize), CompileError> {
        let line0 = block.first().map(|s| s.line).unwrap_or(0);
        let start = self.chunk.len();
        if block.is_empty() {
            self.chunk.emit(Op::LoadUndef, line0);
            self.chunk.emit(Op::BlockReturnValue, line0);
            return Ok((start, self.chunk.len()));
        }
        let last = block.last().expect("non-empty block");
        let StmtKind::Expression(expr) = &last.kind else {
            return Err(CompileError::Unsupported(
                "block last statement must be an expression for bytecode lowering".into(),
            ));
        };
        for stmt in &block[..block.len() - 1] {
            self.compile_statement(stmt)?;
        }
        let line = last.line;
        self.compile_expr(expr)?;
        self.chunk.emit(Op::BlockReturnValue, line);
        Ok((start, self.chunk.len()))
    }

    /// Lower a single expression to `ops` ending in [`Op::BlockReturnValue`].
    ///
    /// Used for `grep EXPR, LIST` (with `$_` set by the VM per item), `eval_timeout EXPR { ... }`,
    /// `keys EXPR` / `values EXPR` operands, `given (TOPIC) { ... }` topic, algebraic `match (SUBJECT)`
    /// subject, and similar one-shot regions matching [`VMHelper::eval_expr`].
    fn try_compile_grep_expr_region(
        &mut self,
        expr: &Expr,
        ctx: WantarrayCtx,
    ) -> Result<(usize, usize), CompileError> {
        let line = expr.line;
        let start = self.chunk.len();
        self.compile_expr_ctx(expr, ctx)?;
        self.chunk.emit(Op::BlockReturnValue, line);
        Ok((start, self.chunk.len()))
    }

    /// Regex flip-flop right operand: boolean rvalue (bare `m//` is `$_ =~ m//`), like `if` / `grep EXPR`.
    fn try_compile_flip_flop_rhs_expr_region(
        &mut self,
        expr: &Expr,
    ) -> Result<(usize, usize), CompileError> {
        let line = expr.line;
        let start = self.chunk.len();
        self.compile_boolean_rvalue_condition(expr)?;
        self.chunk.emit(Op::BlockReturnValue, line);
        Ok((start, self.chunk.len()))
    }

    /// Peephole optimization: if a compiled sub starts with `ShiftArray("_")`
    /// ops and `@_` is not referenced elsewhere, convert those shifts to
    /// `GetArg(n)` and mark the sub entry as `uses_stack_args = true`.
    /// This eliminates Vec allocation + string-based @_ lookup per call.
    fn peephole_stack_args(&mut self, sub_name_idx: u16, entry_ip: usize, underscore_idx: u16) {
        let ops = &self.chunk.ops;
        let end = ops.len();

        // Count leading ShiftArray("_") ops
        let mut shift_count: u8 = 0;
        let mut ip = entry_ip;
        while ip < end {
            if ops[ip] == Op::ShiftArray(underscore_idx) {
                shift_count += 1;
                ip += 1;
            } else {
                break;
            }
        }
        if shift_count == 0 {
            return;
        }

        // Check that @_ is not referenced by any other op in this sub
        let refs_underscore = |op: &Op| -> bool {
            match op {
                Op::GetArray(idx)
                | Op::SetArray(idx)
                | Op::DeclareArray(idx)
                | Op::DeclareArrayFrozen(idx)
                | Op::GetArrayElem(idx)
                | Op::SetArrayElem(idx)
                | Op::SetArrayElemKeep(idx)
                | Op::PushArray(idx)
                | Op::PopArray(idx)
                | Op::ShiftArray(idx)
                | Op::ArrayLen(idx) => *idx == underscore_idx,
                _ => false,
            }
        };

        for op in ops.iter().take(end).skip(entry_ip + shift_count as usize) {
            if refs_underscore(op) {
                return; // @_ used elsewhere, can't optimize
            }
            if matches!(op, Op::Halt | Op::ReturnValue) {
                break; // end of this sub's bytecode
            }
        }

        // Safe to convert: replace ShiftArray("_") with GetArg(n)
        for i in 0..shift_count {
            self.chunk.ops[entry_ip + i as usize] = Op::GetArg(i);
        }

        // Mark sub entry as using stack args
        for e in &mut self.chunk.sub_entries {
            if e.0 == sub_name_idx {
                e.2 = true;
            }
        }
    }

    fn emit_declare_scalar(&mut self, name_idx: u16, line: usize, frozen: bool) {
        let name = self.chunk.names[name_idx as usize].clone();
        self.register_declare(Sigil::Scalar, &name, frozen);
        if frozen {
            self.chunk.emit(Op::DeclareScalarFrozen(name_idx), line);
        } else if let Some(slot) = self.assign_scalar_slot(&name) {
            self.chunk.emit(Op::DeclareScalarSlot(slot, name_idx), line);
        } else {
            self.chunk.emit(Op::DeclareScalar(name_idx), line);
        }
    }

    fn emit_declare_array(&mut self, name_idx: u16, line: usize, frozen: bool) {
        let name = self.chunk.names[name_idx as usize].clone();
        self.register_declare(Sigil::Array, &name, frozen);
        if frozen {
            self.chunk.emit(Op::DeclareArrayFrozen(name_idx), line);
        } else {
            self.chunk.emit(Op::DeclareArray(name_idx), line);
        }
    }

    fn emit_declare_hash(&mut self, name_idx: u16, line: usize, frozen: bool) {
        let name = self.chunk.names[name_idx as usize].clone();
        self.register_declare(Sigil::Hash, &name, frozen);
        if frozen {
            self.chunk.emit(Op::DeclareHashFrozen(name_idx), line);
        } else {
            self.chunk.emit(Op::DeclareHash(name_idx), line);
        }
    }

    fn compile_var_declarations(
        &mut self,
        decls: &[VarDecl],
        line: usize,
        is_my: bool,
    ) -> Result<(), CompileError> {
        let allow_frozen = is_my;
        // List assignment: my ($a, $b) = (10, 20) — distribute elements
        if decls.len() > 1 && decls[0].initializer.is_some() {
            self.compile_expr_ctx(decls[0].initializer.as_ref().unwrap(), WantarrayCtx::List)?;
            let tmp_name = self.chunk.intern_name("__list_assign_tmp__");
            self.emit_declare_array(tmp_name, line, false);
            for (i, decl) in decls.iter().enumerate() {
                let frozen = allow_frozen && decl.frozen;
                match decl.sigil {
                    Sigil::Scalar => {
                        self.chunk.emit(Op::LoadInt(i as i64), line);
                        self.chunk.emit(Op::GetArrayElem(tmp_name), line);
                        if is_my {
                            let name_idx = self.chunk.intern_name(&decl.name);
                            if let Some(ref ty) = decl.type_annotation {
                                let ty_byte = ty.as_byte().ok_or_else(|| {
                                    CompileError::Unsupported(format!(
                                        "typed my with struct type `{}`",
                                        ty.display_name()
                                    ))
                                })?;
                                let name = self.chunk.names[name_idx as usize].clone();
                                self.register_declare(Sigil::Scalar, &name, frozen);
                                if frozen {
                                    self.chunk.emit(
                                        Op::DeclareScalarTypedFrozen(name_idx, ty_byte),
                                        line,
                                    );
                                } else {
                                    self.chunk
                                        .emit(Op::DeclareScalarTyped(name_idx, ty_byte), line);
                                }
                            } else {
                                self.emit_declare_scalar(name_idx, line, frozen);
                            }
                        } else {
                            if decl.type_annotation.is_some() {
                                return Err(CompileError::Unsupported("typed our".into()));
                            }
                            self.emit_declare_our_scalar(&decl.name, line, frozen);
                        }
                    }
                    Sigil::Array => {
                        let name_idx = self
                            .chunk
                            .intern_name(&self.qualify_stash_array_name(&decl.name));
                        // Slurpy `@rest` at position `i` takes `tmp[i..]` (the
                        // tail), not the whole list. (BUG-090)
                        self.chunk
                            .emit(Op::GetArrayFromIndex(tmp_name, i as u16), line);
                        self.emit_declare_array(name_idx, line, frozen);
                    }
                    Sigil::Hash => {
                        let name_idx = self.chunk.intern_name(&decl.name);
                        // Slurpy `%rest` at position `i` takes `tmp[i..]`
                        // pairs, not the whole list. (BUG-090)
                        self.chunk
                            .emit(Op::GetArrayFromIndex(tmp_name, i as u16), line);
                        self.emit_declare_hash(name_idx, line, frozen);
                    }
                    Sigil::Typeglob => {
                        return Err(CompileError::Unsupported(
                            "list assignment to typeglob (my (*a, *b) = ...)".into(),
                        ));
                    }
                }
            }
        } else {
            for decl in decls {
                let frozen = allow_frozen && decl.frozen;
                match decl.sigil {
                    Sigil::Scalar => {
                        if let Some(init) = &decl.initializer {
                            self.compile_expr(init)?;
                        } else {
                            self.chunk.emit(Op::LoadUndef, line);
                        }
                        if is_my {
                            let name_idx = self.chunk.intern_name(&decl.name);
                            if let Some(ref ty) = decl.type_annotation {
                                let ty_byte = ty.as_byte().ok_or_else(|| {
                                    CompileError::Unsupported(format!(
                                        "typed my with struct type `{}`",
                                        ty.display_name()
                                    ))
                                })?;
                                let name = self.chunk.names[name_idx as usize].clone();
                                self.register_declare(Sigil::Scalar, &name, frozen);
                                if frozen {
                                    self.chunk.emit(
                                        Op::DeclareScalarTypedFrozen(name_idx, ty_byte),
                                        line,
                                    );
                                } else {
                                    self.chunk
                                        .emit(Op::DeclareScalarTyped(name_idx, ty_byte), line);
                                }
                            } else {
                                self.emit_declare_scalar(name_idx, line, frozen);
                            }
                        } else {
                            if decl.type_annotation.is_some() {
                                return Err(CompileError::Unsupported("typed our".into()));
                            }
                            self.emit_declare_our_scalar(&decl.name, line, false);
                        }
                    }
                    Sigil::Array => {
                        let name_idx = self
                            .chunk
                            .intern_name(&self.qualify_stash_array_name(&decl.name));
                        if let Some(init) = &decl.initializer {
                            self.compile_expr_ctx(init, WantarrayCtx::List)?;
                        } else {
                            self.chunk.emit(Op::LoadUndef, line);
                        }
                        self.emit_declare_array(name_idx, line, frozen);
                    }
                    Sigil::Hash => {
                        let name_idx = self.chunk.intern_name(&decl.name);
                        if let Some(init) = &decl.initializer {
                            self.compile_expr_ctx(init, WantarrayCtx::List)?;
                        } else {
                            self.chunk.emit(Op::LoadUndef, line);
                        }
                        self.emit_declare_hash(name_idx, line, frozen);
                    }
                    Sigil::Typeglob => {
                        return Err(CompileError::Unsupported("my/our *GLOB".into()));
                    }
                }
            }
        }
        Ok(())
    }

    fn compile_state_declarations(
        &mut self,
        decls: &[VarDecl],
        line: usize,
    ) -> Result<(), CompileError> {
        for decl in decls {
            match decl.sigil {
                Sigil::Scalar => {
                    if let Some(init) = &decl.initializer {
                        self.compile_expr(init)?;
                    } else {
                        self.chunk.emit(Op::LoadUndef, line);
                    }
                    let name_idx = self.chunk.intern_name(&decl.name);
                    let name = self.chunk.names[name_idx as usize].clone();
                    self.register_declare(Sigil::Scalar, &name, false);
                    self.chunk.emit(Op::DeclareStateScalar(name_idx), line);
                }
                Sigil::Array => {
                    let name_idx = self
                        .chunk
                        .intern_name(&self.qualify_stash_array_name(&decl.name));
                    if let Some(init) = &decl.initializer {
                        self.compile_expr_ctx(init, WantarrayCtx::List)?;
                    } else {
                        self.chunk.emit(Op::LoadUndef, line);
                    }
                    self.chunk.emit(Op::DeclareStateArray(name_idx), line);
                }
                Sigil::Hash => {
                    let name_idx = self.chunk.intern_name(&decl.name);
                    if let Some(init) = &decl.initializer {
                        self.compile_expr_ctx(init, WantarrayCtx::List)?;
                    } else {
                        self.chunk.emit(Op::LoadUndef, line);
                    }
                    self.chunk.emit(Op::DeclareStateHash(name_idx), line);
                }
                Sigil::Typeglob => {
                    return Err(CompileError::Unsupported("state *GLOB".into()));
                }
            }
        }
        Ok(())
    }

    fn compile_local_declarations(
        &mut self,
        decls: &[VarDecl],
        line: usize,
    ) -> Result<(), CompileError> {
        if decls.iter().any(|d| d.type_annotation.is_some()) {
            return Err(CompileError::Unsupported("typed local".into()));
        }
        if decls.len() > 1 && decls[0].initializer.is_some() {
            self.compile_expr_ctx(decls[0].initializer.as_ref().unwrap(), WantarrayCtx::List)?;
            let tmp_name = self.chunk.intern_name("__list_assign_tmp__");
            self.emit_declare_array(tmp_name, line, false);
            for (i, decl) in decls.iter().enumerate() {
                match decl.sigil {
                    Sigil::Scalar => {
                        let name_idx = self.intern_scalar_for_local(&decl.name);
                        self.chunk.emit(Op::LoadInt(i as i64), line);
                        self.chunk.emit(Op::GetArrayElem(tmp_name), line);
                        self.chunk.emit(Op::LocalDeclareScalar(name_idx), line);
                    }
                    Sigil::Array => {
                        let q = self.qualify_stash_array_name(&decl.name);
                        let name_idx = self.chunk.intern_name(&q);
                        self.chunk.emit(Op::GetArray(tmp_name), line);
                        self.chunk.emit(Op::LocalDeclareArray(name_idx), line);
                    }
                    Sigil::Hash => {
                        let name_idx = self.chunk.intern_name(&decl.name);
                        self.chunk.emit(Op::GetArray(tmp_name), line);
                        self.chunk.emit(Op::LocalDeclareHash(name_idx), line);
                    }
                    Sigil::Typeglob => {
                        return Err(CompileError::Unsupported(
                            "local (*a,*b,...) with list initializer and typeglob".into(),
                        ));
                    }
                }
            }
        } else {
            for decl in decls {
                match decl.sigil {
                    Sigil::Scalar => {
                        let name_idx = self.intern_scalar_for_local(&decl.name);
                        if let Some(init) = &decl.initializer {
                            self.compile_expr(init)?;
                        } else {
                            self.chunk.emit(Op::LoadUndef, line);
                        }
                        self.chunk.emit(Op::LocalDeclareScalar(name_idx), line);
                    }
                    Sigil::Array => {
                        let q = self.qualify_stash_array_name(&decl.name);
                        let name_idx = self.chunk.intern_name(&q);
                        if let Some(init) = &decl.initializer {
                            self.compile_expr_ctx(init, WantarrayCtx::List)?;
                        } else {
                            self.chunk.emit(Op::LoadUndef, line);
                        }
                        self.chunk.emit(Op::LocalDeclareArray(name_idx), line);
                    }
                    Sigil::Hash => {
                        let name_idx = self.chunk.intern_name(&decl.name);
                        if let Some(init) = &decl.initializer {
                            self.compile_expr_ctx(init, WantarrayCtx::List)?;
                        } else {
                            self.chunk.emit(Op::LoadUndef, line);
                        }
                        self.chunk.emit(Op::LocalDeclareHash(name_idx), line);
                    }
                    Sigil::Typeglob => {
                        let name_idx = self.chunk.intern_name(&decl.name);
                        if let Some(init) = &decl.initializer {
                            let ExprKind::Typeglob(rhs) = &init.kind else {
                                return Err(CompileError::Unsupported(
                                    "local *GLOB = non-typeglob".into(),
                                ));
                            };
                            let rhs_idx = self.chunk.intern_name(rhs);
                            self.chunk
                                .emit(Op::LocalDeclareTypeglob(name_idx, Some(rhs_idx)), line);
                        } else {
                            self.chunk
                                .emit(Op::LocalDeclareTypeglob(name_idx, None), line);
                        }
                    }
                }
            }
        }
        Ok(())
    }

    /// `oursync $x` — package-global counterpart of `mysync`. Wraps the value in
    /// `Arc<Mutex<PerlValue>>` (or `AtomicArray` / `AtomicHash`) like `mysync`, but
    /// keys the binding by the package-qualified stash name (`Pkg::x`) so all
    /// packages and parallel workers share one cell. Mirrors [`Self::emit_declare_our_scalar`]
    /// for name qualification + `register_declare_our_scalar` so later `$x` references
    /// rewrite to `Pkg::x` via [`Self::scalar_storage_name_for_ops`].
    fn compile_oursync_declarations(
        &mut self,
        decls: &[VarDecl],
        line: usize,
    ) -> Result<(), CompileError> {
        for decl in decls {
            if decl.type_annotation.is_some() {
                return Err(CompileError::Unsupported("typed oursync".into()));
            }
            match decl.sigil {
                Sigil::Typeglob => {
                    return Err(CompileError::Unsupported(
                        "`oursync` does not support typeglob variables".into(),
                    ));
                }
                Sigil::Scalar => {
                    if let Some(init) = &decl.initializer {
                        self.compile_expr(init)?;
                    } else {
                        self.chunk.emit(Op::LoadUndef, line);
                    }
                    let stash = self.qualify_stash_scalar_name(&decl.name);
                    let name_idx = self.chunk.intern_name(&stash);
                    self.register_declare_our_scalar(&decl.name);
                    if let Some(layer) = self.scope_stack.last_mut() {
                        layer.mysync_scalars.insert(stash);
                    }
                    self.chunk.emit(Op::DeclareOurSyncScalar(name_idx), line);
                }
                Sigil::Array => {
                    let stash = self.qualify_stash_array_name(&decl.name);
                    if let Some(init) = &decl.initializer {
                        self.compile_expr_ctx(init, WantarrayCtx::List)?;
                    } else {
                        self.chunk.emit(Op::LoadUndef, line);
                    }
                    let name_idx = self.chunk.intern_name(&stash);
                    self.register_declare(Sigil::Array, &stash, false);
                    if let Some(layer) = self.scope_stack.last_mut() {
                        layer.mysync_arrays.insert(stash);
                    }
                    self.chunk.emit(Op::DeclareOurSyncArray(name_idx), line);
                }
                Sigil::Hash => {
                    if let Some(init) = &decl.initializer {
                        self.compile_expr_ctx(init, WantarrayCtx::List)?;
                    } else {
                        self.chunk.emit(Op::LoadUndef, line);
                    }
                    // Hashes follow the existing `our %h` convention and use the
                    // bare name in bytecode (compiler.rs:1722). Cross-package
                    // hash access has separate quirks tracked elsewhere.
                    let name_idx = self.chunk.intern_name(&decl.name);
                    self.register_declare(Sigil::Hash, &decl.name, false);
                    if let Some(layer) = self.scope_stack.last_mut() {
                        layer.mysync_hashes.insert(decl.name.clone());
                    }
                    self.chunk.emit(Op::DeclareOurSyncHash(name_idx), line);
                }
            }
        }
        Ok(())
    }

    fn compile_mysync_declarations(
        &mut self,
        decls: &[VarDecl],
        line: usize,
    ) -> Result<(), CompileError> {
        for decl in decls {
            if decl.type_annotation.is_some() {
                return Err(CompileError::Unsupported("typed mysync".into()));
            }
            match decl.sigil {
                Sigil::Typeglob => {
                    return Err(CompileError::Unsupported(
                        "`mysync` does not support typeglob variables".into(),
                    ));
                }
                Sigil::Scalar => {
                    if let Some(init) = &decl.initializer {
                        self.compile_expr(init)?;
                    } else {
                        self.chunk.emit(Op::LoadUndef, line);
                    }
                    let name_idx = self.chunk.intern_name(&decl.name);
                    self.register_declare(Sigil::Scalar, &decl.name, false);
                    self.chunk.emit(Op::DeclareMySyncScalar(name_idx), line);
                    if let Some(layer) = self.scope_stack.last_mut() {
                        layer.mysync_scalars.insert(decl.name.clone());
                    }
                }
                Sigil::Array => {
                    let stash = self.qualify_stash_array_name(&decl.name);
                    if let Some(init) = &decl.initializer {
                        self.compile_expr_ctx(init, WantarrayCtx::List)?;
                    } else {
                        self.chunk.emit(Op::LoadUndef, line);
                    }
                    let name_idx = self.chunk.intern_name(&stash);
                    self.register_declare(Sigil::Array, &stash, false);
                    self.chunk.emit(Op::DeclareMySyncArray(name_idx), line);
                    if let Some(layer) = self.scope_stack.last_mut() {
                        layer.mysync_arrays.insert(stash);
                    }
                }
                Sigil::Hash => {
                    if let Some(init) = &decl.initializer {
                        self.compile_expr_ctx(init, WantarrayCtx::List)?;
                    } else {
                        self.chunk.emit(Op::LoadUndef, line);
                    }
                    let name_idx = self.chunk.intern_name(&decl.name);
                    self.register_declare(Sigil::Hash, &decl.name, false);
                    self.chunk.emit(Op::DeclareMySyncHash(name_idx), line);
                    if let Some(layer) = self.scope_stack.last_mut() {
                        layer.mysync_hashes.insert(decl.name.clone());
                    }
                }
            }
        }
        Ok(())
    }

    /// `local $h{k} = …` / `local $SIG{__WARN__}` — not plain [`StmtKind::Local`] declarations.
    fn compile_local_expr(
        &mut self,
        target: &Expr,
        initializer: Option<&Expr>,
        line: usize,
    ) -> Result<(), CompileError> {
        match &target.kind {
            ExprKind::HashElement { hash, key } => {
                self.check_strict_hash_access(hash, line)?;
                self.check_hash_mutable(hash, line)?;
                let hash_idx = self.chunk.intern_name(hash);
                if let Some(init) = initializer {
                    self.compile_expr(init)?;
                } else {
                    self.chunk.emit(Op::LoadUndef, line);
                }
                self.compile_expr(key)?;
                self.chunk.emit(Op::LocalDeclareHashElement(hash_idx), line);
                Ok(())
            }
            ExprKind::ArrayElement { array, index } => {
                self.check_strict_array_access(array, line)?;
                let q = self.qualify_stash_array_name(array);
                self.check_array_mutable(&q, line)?;
                let arr_idx = self.chunk.intern_name(&q);
                if let Some(init) = initializer {
                    self.compile_expr(init)?;
                } else {
                    self.chunk.emit(Op::LoadUndef, line);
                }
                self.compile_expr(index)?;
                self.chunk.emit(Op::LocalDeclareArrayElement(arr_idx), line);
                Ok(())
            }
            ExprKind::Typeglob(name) => {
                let lhs_idx = self.chunk.intern_name(name);
                if let Some(init) = initializer {
                    let ExprKind::Typeglob(rhs) = &init.kind else {
                        return Err(CompileError::Unsupported(
                            "local *GLOB = non-typeglob".into(),
                        ));
                    };
                    let rhs_idx = self.chunk.intern_name(rhs);
                    self.chunk
                        .emit(Op::LocalDeclareTypeglob(lhs_idx, Some(rhs_idx)), line);
                } else {
                    self.chunk
                        .emit(Op::LocalDeclareTypeglob(lhs_idx, None), line);
                }
                Ok(())
            }
            ExprKind::Deref {
                expr,
                kind: Sigil::Typeglob,
            } => {
                if let Some(init) = initializer {
                    let ExprKind::Typeglob(rhs) = &init.kind else {
                        return Err(CompileError::Unsupported(
                            "local *GLOB = non-typeglob".into(),
                        ));
                    };
                    let rhs_idx = self.chunk.intern_name(rhs);
                    self.compile_expr(expr)?;
                    self.chunk
                        .emit(Op::LocalDeclareTypeglobDynamic(Some(rhs_idx)), line);
                } else {
                    self.compile_expr(expr)?;
                    self.chunk.emit(Op::LocalDeclareTypeglobDynamic(None), line);
                }
                Ok(())
            }
            ExprKind::TypeglobExpr(expr) => {
                if let Some(init) = initializer {
                    let ExprKind::Typeglob(rhs) = &init.kind else {
                        return Err(CompileError::Unsupported(
                            "local *GLOB = non-typeglob".into(),
                        ));
                    };
                    let rhs_idx = self.chunk.intern_name(rhs);
                    self.compile_expr(expr)?;
                    self.chunk
                        .emit(Op::LocalDeclareTypeglobDynamic(Some(rhs_idx)), line);
                } else {
                    self.compile_expr(expr)?;
                    self.chunk.emit(Op::LocalDeclareTypeglobDynamic(None), line);
                }
                Ok(())
            }
            ExprKind::ScalarVar(name) => {
                let name_idx = self.intern_scalar_for_local(name);
                if let Some(init) = initializer {
                    self.compile_expr(init)?;
                } else {
                    self.chunk.emit(Op::LoadUndef, line);
                }
                self.chunk.emit(Op::LocalDeclareScalar(name_idx), line);
                Ok(())
            }
            ExprKind::ArrayVar(name) => {
                self.check_strict_array_access(name, line)?;
                let q = self.qualify_stash_array_name(name);
                let name_idx = self.chunk.intern_name(&q);
                if let Some(init) = initializer {
                    self.compile_expr_ctx(init, WantarrayCtx::List)?;
                } else {
                    self.chunk.emit(Op::LoadUndef, line);
                }
                self.chunk.emit(Op::LocalDeclareArray(name_idx), line);
                Ok(())
            }
            ExprKind::HashVar(name) => {
                let name_idx = self.chunk.intern_name(name);
                if let Some(init) = initializer {
                    self.compile_expr_ctx(init, WantarrayCtx::List)?;
                } else {
                    self.chunk.emit(Op::LoadUndef, line);
                }
                self.chunk.emit(Op::LocalDeclareHash(name_idx), line);
                Ok(())
            }
            _ => Err(CompileError::Unsupported("local on this lvalue".into())),
        }
    }

    fn compile_statement(&mut self, stmt: &Statement) -> Result<(), CompileError> {
        // A `LABEL:` on a statement binds the label to the IP of the first op emitted for that
        // statement, so that `goto LABEL` can jump to the effective start of execution.
        if let Some(lbl) = &stmt.label {
            self.record_stmt_label(lbl);
        }
        let line = stmt.line;
        match &stmt.kind {
            StmtKind::FormatDecl { name, lines } => {
                let idx = self.chunk.add_format_decl(name.clone(), lines.clone());
                self.chunk.emit(Op::FormatDecl(idx), line);
            }
            StmtKind::Expression(expr) => {
                self.compile_expr_ctx(expr, WantarrayCtx::Void)?;
                self.chunk.emit(Op::Pop, line);
            }
            StmtKind::Local(decls) => self.compile_local_declarations(decls, line)?,
            StmtKind::LocalExpr {
                target,
                initializer,
            } => {
                self.compile_local_expr(target, initializer.as_ref(), line)?;
            }
            StmtKind::MySync(decls) => self.compile_mysync_declarations(decls, line)?,
            StmtKind::OurSync(decls) => self.compile_oursync_declarations(decls, line)?,
            StmtKind::My(decls) => self.compile_var_declarations(decls, line, true)?,
            StmtKind::Our(decls) => self.compile_var_declarations(decls, line, false)?,
            StmtKind::State(decls) => self.compile_state_declarations(decls, line)?,
            StmtKind::If {
                condition,
                body,
                elsifs,
                else_block,
            } => {
                self.compile_boolean_rvalue_condition(condition)?;
                let jump_else = self.chunk.emit(Op::JumpIfFalse(0), line);
                self.compile_block(body)?;
                let mut end_jumps = vec![self.chunk.emit(Op::Jump(0), line)];
                self.chunk.patch_jump_here(jump_else);

                for (cond, blk) in elsifs {
                    self.compile_boolean_rvalue_condition(cond)?;
                    let j = self.chunk.emit(Op::JumpIfFalse(0), cond.line);
                    self.compile_block(blk)?;
                    end_jumps.push(self.chunk.emit(Op::Jump(0), cond.line));
                    self.chunk.patch_jump_here(j);
                }

                if let Some(eb) = else_block {
                    self.compile_block(eb)?;
                }
                for j in end_jumps {
                    self.chunk.patch_jump_here(j);
                }
            }
            StmtKind::Unless {
                condition,
                body,
                else_block,
            } => {
                self.compile_boolean_rvalue_condition(condition)?;
                let jump_else = self.chunk.emit(Op::JumpIfTrue(0), line);
                self.compile_block(body)?;
                if let Some(eb) = else_block {
                    let end_j = self.chunk.emit(Op::Jump(0), line);
                    self.chunk.patch_jump_here(jump_else);
                    self.compile_block(eb)?;
                    self.chunk.patch_jump_here(end_j);
                } else {
                    self.chunk.patch_jump_here(jump_else);
                }
            }
            StmtKind::While {
                condition,
                body,
                label,
                continue_block,
            } => {
                let loop_start = self.chunk.len();
                self.compile_boolean_rvalue_condition(condition)?;
                let exit_jump = self.chunk.emit(Op::JumpIfFalse(0), line);
                let body_start_ip = self.chunk.len();

                self.loop_stack.push(LoopCtx {
                    label: label.clone(),
                    entry_frame_depth: self.frame_depth,
                    entry_try_depth: self.try_depth,
                    body_start_ip,
                    break_jumps: vec![],
                    continue_jumps: vec![],
                });
                self.compile_block_no_frame(body)?;
                // `continue { ... }` runs both on normal fall-through from the body and on
                // `next` (continue_jumps). `last` still bypasses it via break_jumps.
                let continue_entry = self.chunk.len();
                let cont_jumps =
                    std::mem::take(&mut self.loop_stack.last_mut().expect("loop").continue_jumps);
                for j in cont_jumps {
                    self.chunk.patch_jump_to(j, continue_entry);
                }
                if let Some(cb) = continue_block {
                    self.compile_block_no_frame(cb)?;
                }
                self.chunk.emit(Op::Jump(loop_start), line);
                self.chunk.patch_jump_here(exit_jump);
                let ctx = self.loop_stack.pop().expect("loop");
                for j in ctx.break_jumps {
                    self.chunk.patch_jump_here(j);
                }
            }
            StmtKind::Until {
                condition,
                body,
                label,
                continue_block,
            } => {
                let loop_start = self.chunk.len();
                self.compile_boolean_rvalue_condition(condition)?;
                let exit_jump = self.chunk.emit(Op::JumpIfTrue(0), line);
                let body_start_ip = self.chunk.len();

                self.loop_stack.push(LoopCtx {
                    label: label.clone(),
                    entry_frame_depth: self.frame_depth,
                    entry_try_depth: self.try_depth,
                    body_start_ip,
                    break_jumps: vec![],
                    continue_jumps: vec![],
                });
                self.compile_block_no_frame(body)?;
                let continue_entry = self.chunk.len();
                let cont_jumps =
                    std::mem::take(&mut self.loop_stack.last_mut().expect("loop").continue_jumps);
                for j in cont_jumps {
                    self.chunk.patch_jump_to(j, continue_entry);
                }
                if let Some(cb) = continue_block {
                    self.compile_block_no_frame(cb)?;
                }
                self.chunk.emit(Op::Jump(loop_start), line);
                self.chunk.patch_jump_here(exit_jump);
                let ctx = self.loop_stack.pop().expect("loop");
                for j in ctx.break_jumps {
                    self.chunk.patch_jump_here(j);
                }
            }
            StmtKind::For {
                init,
                condition,
                step,
                body,
                label,
                continue_block,
            } => {
                // When the enclosing scope uses scalar slots, skip PushFrame/PopFrame for the
                // C-style `for` so loop variables (`$i`) and outer variables (`$sum`) share the
                // same runtime frame and are both accessible via O(1) slot ops.  The compiler's
                // scope layer still tracks `my` declarations for name resolution; only the runtime
                // frame push is elided.
                let outer_has_slots = self.scope_stack.last().is_some_and(|l| l.use_slots);
                if !outer_has_slots {
                    self.emit_push_frame(line);
                }
                if let Some(init) = init {
                    self.compile_statement(init)?;
                }
                let loop_start = self.chunk.len();
                let cond_exit = if let Some(cond) = condition {
                    self.compile_boolean_rvalue_condition(cond)?;
                    Some(self.chunk.emit(Op::JumpIfFalse(0), line))
                } else {
                    None
                };
                let body_start_ip = self.chunk.len();

                self.loop_stack.push(LoopCtx {
                    label: label.clone(),
                    entry_frame_depth: self.frame_depth,
                    entry_try_depth: self.try_depth,
                    body_start_ip,
                    break_jumps: cond_exit.into_iter().collect(),
                    continue_jumps: vec![],
                });
                self.compile_block_no_frame(body)?;

                let continue_entry = self.chunk.len();
                let cont_jumps =
                    std::mem::take(&mut self.loop_stack.last_mut().expect("loop").continue_jumps);
                for j in cont_jumps {
                    self.chunk.patch_jump_to(j, continue_entry);
                }
                if let Some(cb) = continue_block {
                    self.compile_block_no_frame(cb)?;
                }
                if let Some(step) = step {
                    self.compile_expr(step)?;
                    self.chunk.emit(Op::Pop, line);
                }
                self.chunk.emit(Op::Jump(loop_start), line);

                let ctx = self.loop_stack.pop().expect("loop");
                for j in ctx.break_jumps {
                    self.chunk.patch_jump_here(j);
                }
                if !outer_has_slots {
                    self.emit_pop_frame(line);
                }
            }
            StmtKind::Foreach {
                var,
                list,
                body,
                label,
                continue_block,
            } => {
                // Perl `for ARRAY` aliases the loop variable to each array
                // element — mutations through the loop var propagate back to
                // the array. We approximate by detecting a bare-`@arr` source
                // and emitting a write-back step at the end of each iteration
                // (before the counter increment, after the body and any
                // continue block). Complex sources (lists, ranges, `keys`)
                // keep copy semantics, matching Perl. (BUG-019)
                let alias_array_name_idx: Option<u16> = match &list.kind {
                    ExprKind::ArrayVar(name) => Some(self.chunk.intern_name(name)),
                    _ => None,
                };
                // PushFrame isolates __foreach_list__ / __foreach_i__ from outer/nested loops.
                self.emit_push_frame(line);
                self.compile_expr_ctx(list, WantarrayCtx::List)?;
                let list_name = self.chunk.intern_name("__foreach_list__");
                self.chunk.emit(Op::DeclareArray(list_name), line);

                // Counter and loop variable go in slots so the hot per-iteration ops
                // (`GetScalarSlot` / `PreIncSlot`) skip the linear frame-scalar scan.
                // We cache the slot indices before compiling the body so that any
                // nested foreach / inner `my` that reallocates the same name in the
                // shared scope layer cannot poison our post-body increment op.
                let counter_name = self.chunk.intern_name("__foreach_i__");
                self.chunk.emit(Op::LoadInt(0), line);
                let counter_slot_opt = self.assign_scalar_slot("__foreach_i__");
                if let Some(slot) = counter_slot_opt {
                    self.chunk
                        .emit(Op::DeclareScalarSlot(slot, counter_name), line);
                } else {
                    self.chunk.emit(Op::DeclareScalar(counter_name), line);
                }

                let var_name = self.chunk.intern_name(var);
                self.register_declare(Sigil::Scalar, var, false);
                self.chunk.emit(Op::LoadUndef, line);
                // `$_` is the global topic — keep it in the frame scalars so bareword calls
                // and `print`/`printf` arg-defaulting still see it via the usual special-var
                // path. Slotting it breaks callees that read `$_` across the call boundary.
                let var_slot_opt = if var == "_" {
                    None
                } else {
                    self.assign_scalar_slot(var)
                };
                if let Some(slot) = var_slot_opt {
                    self.chunk.emit(Op::DeclareScalarSlot(slot, var_name), line);
                } else {
                    self.chunk.emit(Op::DeclareScalar(var_name), line);
                }

                let loop_start = self.chunk.len();
                // Check: $i < scalar @list
                if let Some(s) = counter_slot_opt {
                    self.chunk.emit(Op::GetScalarSlot(s), line);
                } else {
                    self.emit_get_scalar(counter_name, line, None);
                }
                self.chunk.emit(Op::ArrayLen(list_name), line);
                self.chunk.emit(Op::NumLt, line);
                let exit_jump = self.chunk.emit(Op::JumpIfFalse(0), line);

                // $var = $list[$i]
                if let Some(s) = counter_slot_opt {
                    self.chunk.emit(Op::GetScalarSlot(s), line);
                } else {
                    self.emit_get_scalar(counter_name, line, None);
                }
                self.chunk.emit(Op::GetArrayElem(list_name), line);
                if let Some(s) = var_slot_opt {
                    self.chunk.emit(Op::SetScalarSlot(s), line);
                } else {
                    self.emit_set_scalar(var_name, line, None);
                }
                let body_start_ip = self.chunk.len();

                self.loop_stack.push(LoopCtx {
                    label: label.clone(),
                    entry_frame_depth: self.frame_depth,
                    entry_try_depth: self.try_depth,
                    body_start_ip,
                    break_jumps: vec![],
                    continue_jumps: vec![],
                });
                self.compile_block_no_frame(body)?;
                // `continue { ... }` on foreach runs after each iteration body (and on `next`),
                // before the iterator increment.
                let step_ip = self.chunk.len();
                let cont_jumps =
                    std::mem::take(&mut self.loop_stack.last_mut().expect("loop").continue_jumps);
                for j in cont_jumps {
                    self.chunk.patch_jump_to(j, step_ip);
                }
                // Alias write-back: $arr[$i] = $loopvar; (BUG-019). Runs at
                // the merged step_ip target so both normal-completion and
                // `next` paths write the loop var's current value back to the
                // source array element.
                if let Some(arr_idx) = alias_array_name_idx {
                    if let Some(s) = var_slot_opt {
                        self.chunk.emit(Op::GetScalarSlot(s), line);
                    } else {
                        self.emit_get_scalar(var_name, line, None);
                    }
                    if let Some(s) = counter_slot_opt {
                        self.chunk.emit(Op::GetScalarSlot(s), line);
                    } else {
                        self.emit_get_scalar(counter_name, line, None);
                    }
                    self.chunk.emit(Op::SetArrayElem(arr_idx), line);
                }
                if let Some(cb) = continue_block {
                    self.compile_block_no_frame(cb)?;
                }

                // $i++ — use the cached slot directly. The scope layer's scalar_slots
                // map may now point `__foreach_i__` at a nested foreach's slot (if any),
                // so we must NOT re-resolve through `emit_pre_inc(counter_name)`.
                if let Some(s) = counter_slot_opt {
                    self.chunk.emit(Op::PreIncSlot(s), line);
                } else {
                    self.emit_pre_inc(counter_name, line, None);
                }
                self.chunk.emit(Op::Pop, line);
                self.chunk.emit(Op::Jump(loop_start), line);

                self.chunk.patch_jump_here(exit_jump);
                let ctx = self.loop_stack.pop().expect("loop");
                for j in ctx.break_jumps {
                    self.chunk.patch_jump_here(j);
                }
                self.emit_pop_frame(line);
            }
            StmtKind::DoWhile { body, condition } => {
                let loop_start = self.chunk.len();
                self.loop_stack.push(LoopCtx {
                    label: None,
                    entry_frame_depth: self.frame_depth,
                    entry_try_depth: self.try_depth,
                    body_start_ip: loop_start,
                    break_jumps: vec![],
                    continue_jumps: vec![],
                });
                self.compile_block_no_frame(body)?;
                let cont_jumps =
                    std::mem::take(&mut self.loop_stack.last_mut().expect("loop").continue_jumps);
                for j in cont_jumps {
                    self.chunk.patch_jump_to(j, loop_start);
                }
                self.compile_boolean_rvalue_condition(condition)?;
                let exit_jump = self.chunk.emit(Op::JumpIfFalse(0), line);
                self.chunk.emit(Op::Jump(loop_start), line);
                self.chunk.patch_jump_here(exit_jump);
                let ctx = self.loop_stack.pop().expect("loop");
                for j in ctx.break_jumps {
                    self.chunk.patch_jump_here(j);
                }
            }
            StmtKind::Goto { target } => {
                // `goto LABEL` where LABEL is a compile-time-known bareword/string: emit a
                // forward `Jump(0)` and record it for patching when the current goto-scope
                // exits. `goto &sub` and `goto $expr` (dynamic target) stay Unsupported.
                if !self.try_emit_goto_label(target, line) {
                    return Err(CompileError::Unsupported(
                        "goto with dynamic or sub-ref target".into(),
                    ));
                }
            }
            StmtKind::Continue(block) => {
                // A bare `continue { ... }` statement (no attached loop) is a parser edge case:
                // Perl just runs the block (`Interpreter::exec_block_smart`).
                // Match that in the VM path.
                for stmt in block {
                    self.compile_statement(stmt)?;
                }
            }
            StmtKind::Return(val) => {
                if let Some(expr) = val {
                    // `return` propagates the caller's wantarray context, so the
                    // operand should be evaluated in list context here. Caller-
                    // side scalar coercion (Op::CallSub in scalar slot) takes the
                    // last element from the returned list — matching Perl's
                    // `return (1, 2, 3)` semantics. (BUG-010)
                    match &expr.kind {
                        ExprKind::Range { .. }
                        | ExprKind::SliceRange { .. }
                        | ExprKind::ArrayVar(_)
                        | ExprKind::List(_)
                        | ExprKind::HashVar(_)
                        | ExprKind::HashSlice { .. }
                        | ExprKind::HashKvSlice { .. }
                        | ExprKind::ArraySlice { .. } => {
                            self.compile_expr_ctx(expr, WantarrayCtx::List)?;
                        }
                        _ => {
                            self.compile_expr(expr)?;
                        }
                    }
                    self.chunk.emit(Op::ReturnValue, line);
                } else {
                    self.chunk.emit(Op::Return, line);
                }
            }
            StmtKind::Last(label) | StmtKind::Next(label) => {
                // Resolve the target loop via `self.loop_stack` — walk from the innermost loop
                // outward, picking the first one that matches the label (or the innermost if
                // `last`/`next` has no label). Emit `(frame_depth - entry_frame_depth)`
                // `PopFrame` ops first so any intervening block / if-body frames are torn down
                // before the jump. `try { }` crossings still bail to tree (see `entry_try_depth`).
                let is_last = matches!(&stmt.kind, StmtKind::Last(_));
                // Search the loop stack (innermost → outermost) for a matching label.
                let (target_idx, entry_frame_depth, entry_try_depth) = {
                    let mut found: Option<(usize, usize, usize)> = None;
                    for (i, lc) in self.loop_stack.iter().enumerate().rev() {
                        let matches = match (label.as_deref(), lc.label.as_deref()) {
                            (None, _) => true, // unlabeled `last`/`next` targets innermost loop
                            (Some(l), Some(lcl)) => l == lcl,
                            (Some(_), None) => false,
                        };
                        if matches {
                            found = Some((i, lc.entry_frame_depth, lc.entry_try_depth));
                            break;
                        }
                    }
                    found.ok_or_else(|| {
                        CompileError::Unsupported(if label.is_some() {
                            format!(
                                "last/next with label `{}` — no matching loop in compile scope",
                                label.as_deref().unwrap_or("")
                            )
                        } else {
                            "last/next outside any loop".into()
                        })
                    })?
                };
                // Cross-try-frame flow control is not modeled in bytecode.
                if self.try_depth != entry_try_depth {
                    return Err(CompileError::Unsupported(
                        "last/next across try { } frame".into(),
                    ));
                }
                // Tear down any scope frames pushed since the loop was entered.
                let frames_to_pop = self.frame_depth.saturating_sub(entry_frame_depth);
                for _ in 0..frames_to_pop {
                    // Emit the `PopFrame` op without decrementing `self.frame_depth` — the
                    // compiler is still emitting code for the enclosing block which will later
                    // emit its own `PopFrame`; we only need the runtime pop here for the
                    // `last`/`next` control path.
                    self.chunk.emit(Op::PopFrame, line);
                }
                let j = self.chunk.emit(Op::Jump(0), line);
                let slot = &mut self.loop_stack[target_idx];
                if is_last {
                    slot.break_jumps.push(j);
                } else {
                    slot.continue_jumps.push(j);
                }
            }
            StmtKind::Redo(label) => {
                let (target_idx, entry_frame_depth, entry_try_depth) = {
                    let mut found: Option<(usize, usize, usize)> = None;
                    for (i, lc) in self.loop_stack.iter().enumerate().rev() {
                        let matches = match (label.as_deref(), lc.label.as_deref()) {
                            (None, _) => true,
                            (Some(l), Some(lcl)) => l == lcl,
                            (Some(_), None) => false,
                        };
                        if matches {
                            found = Some((i, lc.entry_frame_depth, lc.entry_try_depth));
                            break;
                        }
                    }
                    found.ok_or_else(|| {
                        CompileError::Unsupported(if label.is_some() {
                            format!(
                                "redo with label `{}` — no matching loop in compile scope",
                                label.as_deref().unwrap_or("")
                            )
                        } else {
                            "redo outside any loop".into()
                        })
                    })?
                };
                if self.try_depth != entry_try_depth {
                    return Err(CompileError::Unsupported(
                        "redo across try { } frame".into(),
                    ));
                }
                let frames_to_pop = self.frame_depth.saturating_sub(entry_frame_depth);
                for _ in 0..frames_to_pop {
                    self.chunk.emit(Op::PopFrame, line);
                }
                let body_start = self.loop_stack[target_idx].body_start_ip;
                let j = self.chunk.emit(Op::Jump(0), line);
                self.chunk.patch_jump_to(j, body_start);
            }
            StmtKind::Block(block) => {
                self.chunk.emit(Op::PushFrame, line);
                self.compile_block_inner(block)?;
                self.chunk.emit(Op::PopFrame, line);
            }
            StmtKind::StmtGroup(block) => {
                self.compile_block_no_frame(block)?;
            }
            StmtKind::Package { name } => {
                self.current_package = name.clone();
                let val_idx = self.chunk.add_constant(PerlValue::string(name.clone()));
                let name_idx = self.chunk.intern_name("__PACKAGE__");
                self.chunk.emit(Op::LoadConst(val_idx), line);
                self.emit_set_scalar(name_idx, line, None);
            }
            StmtKind::SubDecl {
                name,
                params,
                body,
                prototype,
            } => {
                let idx = self.chunk.runtime_sub_decls.len();
                if idx > u16::MAX as usize {
                    return Err(CompileError::Unsupported(
                        "too many runtime sub declarations in one chunk".into(),
                    ));
                }
                self.chunk.runtime_sub_decls.push(RuntimeSubDecl {
                    name: name.clone(),
                    params: params.clone(),
                    body: body.clone(),
                    prototype: prototype.clone(),
                });
                self.chunk.emit(Op::RuntimeSubDecl(idx as u16), line);
            }
            StmtKind::AdviceDecl {
                kind,
                pattern,
                body,
            } => {
                let idx = self.chunk.runtime_advice_decls.len();
                if idx > u16::MAX as usize {
                    return Err(CompileError::Unsupported(
                        "too many AOP advice declarations in one chunk".into(),
                    ));
                }
                // Register the body as a chunk block so the fourth-pass lowering
                // (`Compiler::compile_program` / `block_bytecode_ranges`) emits its
                // bytecode and `run_block_region` can dispatch it. This keeps the
                // body on the VM bytecode path — the tree-walker (`exec_block`) is
                // banned for advice. See `tests/tree_walker_absent_aop.rs`.
                let body_block_idx = self.add_deferred_block(body.clone());
                self.chunk.runtime_advice_decls.push(RuntimeAdviceDecl {
                    kind: *kind,
                    pattern: pattern.clone(),
                    body: body.clone(),
                    body_block_idx,
                });
                self.chunk.emit(Op::RegisterAdvice(idx as u16), line);
            }
            StmtKind::StructDecl { def } => {
                if self.chunk.struct_defs.iter().any(|d| d.name == def.name) {
                    return Err(CompileError::Unsupported(format!(
                        "duplicate struct `{}`",
                        def.name
                    )));
                }
                self.chunk.struct_defs.push(def.clone());
            }
            StmtKind::EnumDecl { def } => {
                if self.chunk.enum_defs.iter().any(|d| d.name == def.name) {
                    return Err(CompileError::Unsupported(format!(
                        "duplicate enum `{}`",
                        def.name
                    )));
                }
                self.chunk.enum_defs.push(def.clone());
            }
            StmtKind::ClassDecl { def } => {
                if self.chunk.class_defs.iter().any(|d| d.name == def.name) {
                    return Err(CompileError::Unsupported(format!(
                        "duplicate class `{}`",
                        def.name
                    )));
                }
                self.chunk.class_defs.push(def.clone());
            }
            StmtKind::TraitDecl { def } => {
                if self.chunk.trait_defs.iter().any(|d| d.name == def.name) {
                    return Err(CompileError::Unsupported(format!(
                        "duplicate trait `{}`",
                        def.name
                    )));
                }
                self.chunk.trait_defs.push(def.clone());
            }
            StmtKind::TryCatch {
                try_block,
                catch_var,
                catch_block,
                finally_block,
            } => {
                let catch_var_idx = self.chunk.intern_name(catch_var);
                let try_push_idx = self.chunk.emit(
                    Op::TryPush {
                        catch_ip: 0,
                        finally_ip: None,
                        after_ip: 0,
                        catch_var_idx,
                    },
                    line,
                );
                self.chunk.emit(Op::PushFrame, line);
                if self.program_last_stmt_takes_value {
                    self.emit_block_value(try_block, line)?;
                } else {
                    self.compile_block_inner(try_block)?;
                }
                self.chunk.emit(Op::PopFrame, line);
                self.chunk.emit(Op::TryContinueNormal, line);

                let catch_start = self.chunk.len();
                self.chunk.patch_try_push_catch(try_push_idx, catch_start);

                self.chunk.emit(Op::CatchReceive(catch_var_idx), line);
                if self.program_last_stmt_takes_value {
                    self.emit_block_value(catch_block, line)?;
                } else {
                    self.compile_block_inner(catch_block)?;
                }
                self.chunk.emit(Op::PopFrame, line);
                self.chunk.emit(Op::TryContinueNormal, line);

                if let Some(fin) = finally_block {
                    let finally_start = self.chunk.len();
                    self.chunk
                        .patch_try_push_finally(try_push_idx, Some(finally_start));
                    self.chunk.emit(Op::PushFrame, line);
                    self.compile_block_inner(fin)?;
                    self.chunk.emit(Op::PopFrame, line);
                    self.chunk.emit(Op::TryFinallyEnd, line);
                }
                let merge = self.chunk.len();
                self.chunk.patch_try_push_after(try_push_idx, merge);
            }
            StmtKind::EvalTimeout { timeout, body } => {
                let idx = self
                    .chunk
                    .add_eval_timeout_entry(timeout.clone(), body.clone());
                self.chunk.emit(Op::EvalTimeout(idx), line);
            }
            StmtKind::Given { topic, body } => {
                let idx = self.chunk.add_given_entry(topic.clone(), body.clone());
                self.chunk.emit(Op::Given(idx), line);
            }
            StmtKind::When { .. } | StmtKind::DefaultCase { .. } => {
                return Err(CompileError::Unsupported(
                    "`when` / `default` only valid inside `given`".into(),
                ));
            }
            StmtKind::Tie {
                target,
                class,
                args,
            } => {
                self.compile_expr(class)?;
                for a in args {
                    self.compile_expr(a)?;
                }
                let (kind, name_idx) = match target {
                    TieTarget::Scalar(s) => (0u8, self.chunk.intern_name(s)),
                    TieTarget::Array(a) => (1u8, self.chunk.intern_name(a)),
                    TieTarget::Hash(h) => (2u8, self.chunk.intern_name(h)),
                };
                let argc = (1 + args.len()) as u8;
                self.chunk.emit(
                    Op::Tie {
                        target_kind: kind,
                        name_idx,
                        argc,
                    },
                    line,
                );
            }
            StmtKind::UseOverload { pairs } => {
                let idx = self.chunk.add_use_overload(pairs.clone());
                self.chunk.emit(Op::UseOverload(idx), line);
            }
            StmtKind::Use { module, imports } => {
                // `use Env '@PATH'` declares variables that must be visible to strict checking.
                if module == "Env" {
                    Self::register_env_imports(
                        self.scope_stack.last_mut().expect("scope"),
                        imports,
                    );
                }
            }
            StmtKind::UsePerlVersion { .. }
            | StmtKind::No { .. }
            | StmtKind::Begin(_)
            | StmtKind::UnitCheck(_)
            | StmtKind::Check(_)
            | StmtKind::Init(_)
            | StmtKind::End(_)
            | StmtKind::Empty => {
                // No-ops or handled elsewhere
            }
        }
        Ok(())
    }

    /// Returns true if the block contains a Return statement (directly, not in nested subs).
    fn block_has_return(block: &Block) -> bool {
        for stmt in block {
            match &stmt.kind {
                StmtKind::Return(_) => return true,
                StmtKind::If {
                    body,
                    elsifs,
                    else_block,
                    ..
                } => {
                    if Self::block_has_return(body) {
                        return true;
                    }
                    for (_, blk) in elsifs {
                        if Self::block_has_return(blk) {
                            return true;
                        }
                    }
                    if let Some(eb) = else_block {
                        if Self::block_has_return(eb) {
                            return true;
                        }
                    }
                }
                StmtKind::Unless {
                    body, else_block, ..
                } => {
                    if Self::block_has_return(body) {
                        return true;
                    }
                    if let Some(eb) = else_block {
                        if Self::block_has_return(eb) {
                            return true;
                        }
                    }
                }
                StmtKind::While { body, .. }
                | StmtKind::Until { body, .. }
                | StmtKind::Foreach { body, .. }
                    if Self::block_has_return(body) =>
                {
                    return true;
                }
                StmtKind::For { body, .. } if Self::block_has_return(body) => {
                    return true;
                }
                StmtKind::Block(blk) if Self::block_has_return(blk) => {
                    return true;
                }
                StmtKind::DoWhile { body, .. } if Self::block_has_return(body) => {
                    return true;
                }
                _ => {}
            }
        }
        false
    }

    /// Returns true if the block contains a local declaration.
    fn block_has_local(block: &Block) -> bool {
        block.iter().any(|s| match &s.kind {
            StmtKind::Local(_) | StmtKind::LocalExpr { .. } => true,
            StmtKind::StmtGroup(inner) => Self::block_has_local(inner),
            _ => false,
        })
    }

    fn compile_block(&mut self, block: &Block) -> Result<(), CompileError> {
        if Self::block_has_return(block) {
            self.compile_block_inner(block)?;
        } else if self.scope_stack.last().is_some_and(|l| l.use_slots)
            && !Self::block_has_local(block)
        {
            // When scalar slots are active, skip PushFrame/PopFrame so slot indices keep
            // addressing the same runtime frame. New `my` decls still get fresh slot indices.
            self.compile_block_inner(block)?;
        } else {
            self.push_scope_layer();
            self.chunk.emit(Op::PushFrame, 0);
            self.compile_block_inner(block)?;
            self.chunk.emit(Op::PopFrame, 0);
            self.pop_scope_layer();
        }
        Ok(())
    }

    fn compile_block_inner(&mut self, block: &Block) -> Result<(), CompileError> {
        for stmt in block {
            self.compile_statement(stmt)?;
        }
        Ok(())
    }

    /// Compile a block that leaves its last expression's value on the stack.
    /// Used for if/unless as the last statement (implicit return).
    fn emit_block_value(&mut self, block: &Block, line: usize) -> Result<(), CompileError> {
        if block.is_empty() {
            self.chunk.emit(Op::LoadUndef, line);
            return Ok(());
        }
        let last_idx = block.len() - 1;
        for (i, stmt) in block.iter().enumerate() {
            if i == last_idx {
                match &stmt.kind {
                    StmtKind::Expression(expr) => {
                        self.compile_expr(expr)?;
                    }
                    StmtKind::Block(inner) => {
                        self.chunk.emit(Op::PushFrame, stmt.line);
                        self.emit_block_value(inner, stmt.line)?;
                        self.chunk.emit(Op::PopFrame, stmt.line);
                    }
                    StmtKind::StmtGroup(inner) => {
                        self.emit_block_value(inner, stmt.line)?;
                    }
                    StmtKind::If {
                        condition,
                        body,
                        elsifs,
                        else_block,
                    } => {
                        self.compile_boolean_rvalue_condition(condition)?;
                        let j0 = self.chunk.emit(Op::JumpIfFalse(0), stmt.line);
                        self.emit_block_value(body, stmt.line)?;
                        let mut ends = vec![self.chunk.emit(Op::Jump(0), stmt.line)];
                        self.chunk.patch_jump_here(j0);
                        for (c, blk) in elsifs {
                            self.compile_boolean_rvalue_condition(c)?;
                            let j = self.chunk.emit(Op::JumpIfFalse(0), c.line);
                            self.emit_block_value(blk, c.line)?;
                            ends.push(self.chunk.emit(Op::Jump(0), c.line));
                            self.chunk.patch_jump_here(j);
                        }
                        if let Some(eb) = else_block {
                            self.emit_block_value(eb, stmt.line)?;
                        } else {
                            self.chunk.emit(Op::LoadUndef, stmt.line);
                        }
                        for j in ends {
                            self.chunk.patch_jump_here(j);
                        }
                    }
                    StmtKind::Unless {
                        condition,
                        body,
                        else_block,
                    } => {
                        self.compile_boolean_rvalue_condition(condition)?;
                        let j0 = self.chunk.emit(Op::JumpIfFalse(0), stmt.line);
                        if let Some(eb) = else_block {
                            self.emit_block_value(eb, stmt.line)?;
                        } else {
                            self.chunk.emit(Op::LoadUndef, stmt.line);
                        }
                        let end = self.chunk.emit(Op::Jump(0), stmt.line);
                        self.chunk.patch_jump_here(j0);
                        self.emit_block_value(body, stmt.line)?;
                        self.chunk.patch_jump_here(end);
                    }
                    _ => self.compile_statement(stmt)?,
                }
            } else {
                self.compile_statement(stmt)?;
            }
        }
        Ok(())
    }

    /// Compile a subroutine body so the return value matches Perl: the last statement's value is
    /// returned when it is an expression or a trailing `if`/`unless` (same shape as the main
    /// program's last-statement value rule). Otherwise falls through with `undef` after the last
    /// statement unless it already executed `return`.
    fn emit_subroutine_body_return(&mut self, body: &Block) -> Result<(), CompileError> {
        if body.is_empty() {
            self.chunk.emit(Op::LoadUndef, 0);
            self.chunk.emit(Op::ReturnValue, 0);
            return Ok(());
        }
        let last_idx = body.len() - 1;
        let last = &body[last_idx];
        match &last.kind {
            StmtKind::Return(_) => {
                for stmt in body {
                    self.compile_statement(stmt)?;
                }
            }
            StmtKind::Expression(expr) => {
                for stmt in &body[..last_idx] {
                    self.compile_statement(stmt)?;
                }
                // Compile tail expression in List context so @array returns
                // the array contents, not the count. The caller's ReturnValue
                // handler will adapt to the actual wantarray context.
                self.compile_expr_ctx(expr, WantarrayCtx::List)?;
                self.chunk.emit(Op::ReturnValue, last.line);
            }
            StmtKind::If {
                condition,
                body: if_body,
                elsifs,
                else_block,
            } => {
                for stmt in &body[..last_idx] {
                    self.compile_statement(stmt)?;
                }
                self.compile_boolean_rvalue_condition(condition)?;
                let j0 = self.chunk.emit(Op::JumpIfFalse(0), last.line);
                self.emit_block_value(if_body, last.line)?;
                let mut ends = vec![self.chunk.emit(Op::Jump(0), last.line)];
                self.chunk.patch_jump_here(j0);
                for (c, blk) in elsifs {
                    self.compile_boolean_rvalue_condition(c)?;
                    let j = self.chunk.emit(Op::JumpIfFalse(0), c.line);
                    self.emit_block_value(blk, c.line)?;
                    ends.push(self.chunk.emit(Op::Jump(0), c.line));
                    self.chunk.patch_jump_here(j);
                }
                if let Some(eb) = else_block {
                    self.emit_block_value(eb, last.line)?;
                } else {
                    self.chunk.emit(Op::LoadUndef, last.line);
                }
                for j in ends {
                    self.chunk.patch_jump_here(j);
                }
                self.chunk.emit(Op::ReturnValue, last.line);
            }
            StmtKind::Unless {
                condition,
                body: unless_body,
                else_block,
            } => {
                for stmt in &body[..last_idx] {
                    self.compile_statement(stmt)?;
                }
                self.compile_boolean_rvalue_condition(condition)?;
                let j0 = self.chunk.emit(Op::JumpIfFalse(0), last.line);
                if let Some(eb) = else_block {
                    self.emit_block_value(eb, last.line)?;
                } else {
                    self.chunk.emit(Op::LoadUndef, last.line);
                }
                let end = self.chunk.emit(Op::Jump(0), last.line);
                self.chunk.patch_jump_here(j0);
                self.emit_block_value(unless_body, last.line)?;
                self.chunk.patch_jump_here(end);
                self.chunk.emit(Op::ReturnValue, last.line);
            }
            _ => {
                for stmt in body {
                    self.compile_statement(stmt)?;
                }
                self.chunk.emit(Op::LoadUndef, 0);
                self.chunk.emit(Op::ReturnValue, 0);
            }
        }
        Ok(())
    }

    /// Compile a loop body as a sequence of statements. `last`/`next` (including those nested
    /// inside `if`/`unless`/block statements) are handled by `compile_statement` via the
    /// [`Compiler::loop_stack`] — the innermost loop frame owns their break/continue patches.
    fn compile_block_no_frame(&mut self, block: &Block) -> Result<(), CompileError> {
        for stmt in block {
            self.compile_statement(stmt)?;
        }
        Ok(())
    }

    fn compile_expr(&mut self, expr: &Expr) -> Result<(), CompileError> {
        self.compile_expr_ctx(expr, WantarrayCtx::Scalar)
    }

    fn compile_expr_ctx(&mut self, root: &Expr, ctx: WantarrayCtx) -> Result<(), CompileError> {
        let line = root.line;
        match &root.kind {
            ExprKind::Integer(n) => {
                self.emit_op(Op::LoadInt(*n), line, Some(root));
            }
            ExprKind::Float(f) => {
                self.emit_op(Op::LoadFloat(*f), line, Some(root));
            }
            ExprKind::String(s) => {
                let processed = VMHelper::process_case_escapes(s);
                let idx = self.chunk.add_constant(PerlValue::string(processed));
                self.emit_op(Op::LoadConst(idx), line, Some(root));
            }
            ExprKind::Bareword(name) => {
                // `BAREWORD` as an rvalue: run-time lookup via `Op::BarewordRvalue` — if a sub
                // with this name exists at run time, call it nullary; otherwise push the name
                // as a string. Mirrors Perl's `ExprKind::Bareword` eval path.
                let idx = self.chunk.intern_name(name);
                self.emit_op(Op::BarewordRvalue(idx), line, Some(root));
            }
            ExprKind::Undef => {
                self.emit_op(Op::LoadUndef, line, Some(root));
            }
            ExprKind::MagicConst(crate::ast::MagicConstKind::File) => {
                let idx = self
                    .chunk
                    .add_constant(PerlValue::string(self.source_file.clone()));
                self.emit_op(Op::LoadConst(idx), line, Some(root));
            }
            ExprKind::MagicConst(crate::ast::MagicConstKind::Line) => {
                let idx = self
                    .chunk
                    .add_constant(PerlValue::integer(root.line as i64));
                self.emit_op(Op::LoadConst(idx), line, Some(root));
            }
            ExprKind::MagicConst(crate::ast::MagicConstKind::Sub) => {
                self.emit_op(Op::LoadCurrentSub, line, Some(root));
            }
            ExprKind::ScalarVar(name) => {
                self.check_strict_scalar_access(name, line)?;
                let idx = self.intern_scalar_var_for_ops(name);
                self.emit_get_scalar(idx, line, Some(root));
            }
            ExprKind::ArrayVar(name) => {
                self.check_strict_array_access(name, line)?;
                let idx = self.chunk.intern_name(&self.qualify_stash_array_name(name));
                if ctx == WantarrayCtx::List {
                    self.emit_op(Op::GetArray(idx), line, Some(root));
                } else {
                    self.emit_op(Op::ArrayLen(idx), line, Some(root));
                }
            }
            ExprKind::HashVar(name) => {
                self.check_strict_hash_access(name, line)?;
                let idx = self.chunk.intern_name(name);
                self.emit_op(Op::GetHash(idx), line, Some(root));
                if ctx != WantarrayCtx::List {
                    self.emit_op(Op::ValueScalarContext, line, Some(root));
                }
            }
            ExprKind::Typeglob(name) => {
                let idx = self.chunk.add_constant(PerlValue::string(name.clone()));
                self.emit_op(Op::LoadConst(idx), line, Some(root));
            }
            ExprKind::TypeglobExpr(expr) => {
                self.compile_expr(expr)?;
                self.emit_op(Op::LoadDynamicTypeglob, line, Some(root));
            }
            ExprKind::ArrayElement { array, index } => {
                self.check_strict_array_access(array, line)?;
                let idx = self
                    .chunk
                    .intern_name(&self.qualify_stash_array_name(array));
                // Stryke string-slice sugar: `$s[from:to]` / `$s[from:to:step]`
                // returns a substring (or stepped pick) when the target is a
                // scalar string. Compile to ArraySliceRange — the VM handles
                // the scalar-string case when the array is empty.
                if let ExprKind::Range {
                    from,
                    to,
                    exclusive,
                    step,
                } = &index.kind
                {
                    self.compile_expr(from)?;
                    self.compile_expr(to)?;
                    self.compile_optional_or_undef(step.as_deref())?;
                    let _ = exclusive; // ArraySliceRange semantics treat to as inclusive
                    self.emit_op(Op::ArraySliceRange(idx), line, Some(root));
                    return Ok(());
                }
                self.compile_expr(index)?;
                self.emit_op(Op::GetArrayElem(idx), line, Some(root));
            }
            ExprKind::HashElement { hash, key } => {
                self.check_strict_hash_access(hash, line)?;
                let idx = self.chunk.intern_name(hash);
                self.compile_expr(key)?;
                self.emit_op(Op::GetHashElem(idx), line, Some(root));
            }
            ExprKind::ArraySlice { array, indices } => {
                let arr_idx = self
                    .chunk
                    .intern_name(&self.qualify_stash_array_name(array));
                if indices.is_empty() {
                    self.emit_op(Op::MakeArray(0), line, Some(root));
                } else if indices.len() == 1 {
                    match &indices[0].kind {
                        ExprKind::SliceRange { from, to, step } => {
                            // Open-ended slice — push (from?, to?, step?); VM resolves
                            // defaults from array length. Integer-strict; aborts on
                            // non-integer endpoints.
                            self.compile_optional_or_undef(from.as_deref())?;
                            self.compile_optional_or_undef(to.as_deref())?;
                            self.compile_optional_or_undef(step.as_deref())?;
                            self.emit_op(Op::ArraySliceRange(arr_idx), line, Some(root));
                        }
                        ExprKind::Range { from, to, step, .. } => {
                            // Closed colon range like `1:3` or `1:3:2` — also strict
                            // integer (rejects `"a":"c"`, `1.5:5`, etc.).
                            self.compile_expr(from)?;
                            self.compile_expr(to)?;
                            self.compile_optional_or_undef(step.as_deref())?;
                            self.emit_op(Op::ArraySliceRange(arr_idx), line, Some(root));
                        }
                        _ => {
                            self.compile_array_slice_index_expr(&indices[0])?;
                            self.emit_op(Op::ArraySlicePart(arr_idx), line, Some(root));
                        }
                    }
                } else {
                    for (ix, index_expr) in indices.iter().enumerate() {
                        self.compile_array_slice_index_expr(index_expr)?;
                        self.emit_op(Op::ArraySlicePart(arr_idx), line, Some(root));
                        if ix > 0 {
                            self.emit_op(Op::ArrayConcatTwo, line, Some(root));
                        }
                    }
                }
            }
            ExprKind::HashSlice { hash, keys } => {
                let hash_idx = self.chunk.intern_name(hash);
                if keys.len() == 1 {
                    match &keys[0].kind {
                        ExprKind::SliceRange { from, to, step } => {
                            // Open-ended hash slice — VM aborts (no "all keys" in
                            // unordered hash).
                            self.compile_optional_or_undef(from.as_deref())?;
                            self.compile_optional_or_undef(to.as_deref())?;
                            self.compile_optional_or_undef(step.as_deref())?;
                            self.emit_op(Op::HashSliceRange(hash_idx), line, Some(root));
                            return Ok(());
                        }
                        ExprKind::Range { from, to, step, .. } => {
                            // Closed colon range like `a:c:1` or `1:3` — endpoints
                            // stringify to hash keys (auto-quoted barewords already
                            // resolved during parsing).
                            self.compile_expr(from)?;
                            self.compile_expr(to)?;
                            self.compile_optional_or_undef(step.as_deref())?;
                            self.emit_op(Op::HashSliceRange(hash_idx), line, Some(root));
                            return Ok(());
                        }
                        _ => {}
                    }
                }
                // If any key expression is a range, we need runtime flattening via GetHashSlice.
                let has_dynamic_keys = keys
                    .iter()
                    .any(|k| matches!(&k.kind, ExprKind::Range { .. }));
                if has_dynamic_keys {
                    for key_expr in keys {
                        self.compile_hash_slice_key_expr(key_expr)?;
                    }
                    self.emit_op(
                        Op::GetHashSlice(hash_idx, keys.len() as u16),
                        line,
                        Some(root),
                    );
                } else {
                    // Flatten multi-key subscripts (qw, lists) into individual GetHashElem ops
                    let mut total_keys = 0u16;
                    for key_expr in keys {
                        match &key_expr.kind {
                            ExprKind::QW(words) => {
                                for w in words {
                                    let cidx =
                                        self.chunk.add_constant(PerlValue::string(w.clone()));
                                    self.emit_op(Op::LoadConst(cidx), line, Some(root));
                                    self.emit_op(Op::GetHashElem(hash_idx), line, Some(root));
                                    total_keys += 1;
                                }
                            }
                            ExprKind::List(elems) => {
                                for e in elems {
                                    self.compile_expr(e)?;
                                    self.emit_op(Op::GetHashElem(hash_idx), line, Some(root));
                                    total_keys += 1;
                                }
                            }
                            _ => {
                                self.compile_expr(key_expr)?;
                                self.emit_op(Op::GetHashElem(hash_idx), line, Some(root));
                                total_keys += 1;
                            }
                        }
                    }
                    self.emit_op(Op::MakeArray(total_keys), line, Some(root));
                }
            }
            ExprKind::HashKvSlice { hash, keys } => {
                // `%h{KEYS}` — Perl 5.20+ kv-slice. Emit key-then-value
                // pairs, then MakeArray for a flat list. (BUG-008)
                let hash_idx = self.chunk.intern_name(hash);
                let mut total_pairs = 0u16;
                for key_expr in keys {
                    match &key_expr.kind {
                        ExprKind::QW(words) => {
                            for w in words {
                                let kidx = self.chunk.add_constant(PerlValue::string(w.clone()));
                                self.emit_op(Op::LoadConst(kidx), line, Some(root));
                                let kidx2 = self.chunk.add_constant(PerlValue::string(w.clone()));
                                self.emit_op(Op::LoadConst(kidx2), line, Some(root));
                                self.emit_op(Op::GetHashElem(hash_idx), line, Some(root));
                                total_pairs += 1;
                            }
                        }
                        ExprKind::List(elems) => {
                            for e in elems {
                                self.compile_expr(e)?;
                                self.emit_op(Op::Dup, line, Some(root));
                                self.emit_op(Op::GetHashElem(hash_idx), line, Some(root));
                                total_pairs += 1;
                            }
                        }
                        _ => {
                            self.compile_expr(key_expr)?;
                            self.emit_op(Op::Dup, line, Some(root));
                            self.emit_op(Op::GetHashElem(hash_idx), line, Some(root));
                            total_pairs += 1;
                        }
                    }
                }
                self.emit_op(Op::MakeArray(total_pairs * 2), line, Some(root));
            }
            ExprKind::HashSliceDeref { container, keys } => {
                self.compile_expr(container)?;
                for key_expr in keys {
                    self.compile_hash_slice_key_expr(key_expr)?;
                }
                self.emit_op(Op::HashSliceDeref(keys.len() as u16), line, Some(root));
            }
            ExprKind::AnonymousListSlice { source, indices } => {
                if indices.is_empty() {
                    self.compile_expr_ctx(source, WantarrayCtx::List)?;
                    self.emit_op(Op::MakeArray(0), line, Some(root));
                } else {
                    self.compile_expr_ctx(source, WantarrayCtx::List)?;
                    for index_expr in indices {
                        self.compile_array_slice_index_expr(index_expr)?;
                    }
                    self.emit_op(Op::ArrowArraySlice(indices.len() as u16), line, Some(root));
                }
                if ctx != WantarrayCtx::List {
                    self.emit_op(Op::ListSliceToScalar, line, Some(root));
                }
            }

            // ── Operators ──
            ExprKind::BinOp { left, op, right } => {
                // Short-circuit operators
                match op {
                    BinOp::LogAnd | BinOp::LogAndWord => {
                        if matches!(left.kind, ExprKind::Regex(..)) {
                            self.compile_boolean_rvalue_condition(left)?;
                            self.emit_op(Op::RegexBoolToScalar, line, Some(root));
                        } else {
                            self.compile_expr(left)?;
                        }
                        let j = self.emit_op(Op::JumpIfFalseKeep(0), line, Some(root));
                        // JumpIfFalseKeep already pops on fall-through, so no explicit Pop needed
                        if matches!(right.kind, ExprKind::Regex(..)) {
                            self.compile_boolean_rvalue_condition(right)?;
                            self.emit_op(Op::RegexBoolToScalar, line, Some(root));
                        } else {
                            self.compile_expr(right)?;
                        }
                        self.chunk.patch_jump_here(j);
                        return Ok(());
                    }
                    BinOp::LogOr | BinOp::LogOrWord => {
                        if matches!(left.kind, ExprKind::Regex(..)) {
                            self.compile_boolean_rvalue_condition(left)?;
                            self.emit_op(Op::RegexBoolToScalar, line, Some(root));
                        } else {
                            self.compile_expr(left)?;
                        }
                        let j = self.emit_op(Op::JumpIfTrueKeep(0), line, Some(root));
                        // JumpIfTrueKeep already pops on fall-through, so no explicit Pop needed
                        if matches!(right.kind, ExprKind::Regex(..)) {
                            self.compile_boolean_rvalue_condition(right)?;
                            self.emit_op(Op::RegexBoolToScalar, line, Some(root));
                        } else {
                            self.compile_expr(right)?;
                        }
                        self.chunk.patch_jump_here(j);
                        return Ok(());
                    }
                    BinOp::DefinedOr => {
                        self.compile_expr(left)?;
                        let j = self.emit_op(Op::JumpIfDefinedKeep(0), line, Some(root));
                        // JumpIfDefinedKeep already pops on fall-through, so no explicit Pop needed
                        self.compile_expr(right)?;
                        self.chunk.patch_jump_here(j);
                        return Ok(());
                    }
                    BinOp::BindMatch => {
                        self.compile_expr(left)?;
                        self.compile_expr(right)?;
                        self.emit_op(Op::RegexMatchDyn(false), line, Some(root));
                        return Ok(());
                    }
                    BinOp::BindNotMatch => {
                        self.compile_expr(left)?;
                        self.compile_expr(right)?;
                        self.emit_op(Op::RegexMatchDyn(true), line, Some(root));
                        return Ok(());
                    }
                    _ => {}
                }

                self.compile_expr(left)?;
                self.compile_expr(right)?;
                let op_code = match op {
                    BinOp::Add => Op::Add,
                    BinOp::Sub => Op::Sub,
                    BinOp::Mul => Op::Mul,
                    BinOp::Div => Op::Div,
                    BinOp::Mod => Op::Mod,
                    BinOp::Pow => Op::Pow,
                    BinOp::Concat => Op::Concat,
                    BinOp::NumEq => Op::NumEq,
                    BinOp::NumNe => Op::NumNe,
                    BinOp::NumLt => Op::NumLt,
                    BinOp::NumGt => Op::NumGt,
                    BinOp::NumLe => Op::NumLe,
                    BinOp::NumGe => Op::NumGe,
                    BinOp::Spaceship => Op::Spaceship,
                    BinOp::StrEq => Op::StrEq,
                    BinOp::StrNe => Op::StrNe,
                    BinOp::StrLt => Op::StrLt,
                    BinOp::StrGt => Op::StrGt,
                    BinOp::StrLe => Op::StrLe,
                    BinOp::StrGe => Op::StrGe,
                    BinOp::StrCmp => Op::StrCmp,
                    BinOp::BitAnd => Op::BitAnd,
                    BinOp::BitOr => Op::BitOr,
                    BinOp::BitXor => Op::BitXor,
                    BinOp::ShiftLeft => Op::Shl,
                    BinOp::ShiftRight => Op::Shr,
                    // Short-circuit and regex bind handled above
                    BinOp::LogAnd
                    | BinOp::LogOr
                    | BinOp::DefinedOr
                    | BinOp::LogAndWord
                    | BinOp::LogOrWord
                    | BinOp::BindMatch
                    | BinOp::BindNotMatch => unreachable!(),
                };
                self.emit_op(op_code, line, Some(root));
            }

            ExprKind::UnaryOp { op, expr } => match op {
                UnaryOp::PreIncrement => {
                    if let ExprKind::ScalarVar(name) = &expr.kind {
                        self.check_scalar_mutable(name, line)?;
                        self.check_closure_write_to_outer_my(name, line)?;
                        let idx = self.intern_scalar_var_for_ops(name);
                        self.emit_pre_inc(idx, line, Some(root));
                    } else if let ExprKind::ArrayElement { array, index } = &expr.kind {
                        if self.is_mysync_array(array) {
                            return Err(CompileError::Unsupported(
                                "mysync array element update".into(),
                            ));
                        }
                        let q = self.qualify_stash_array_name(array);
                        self.check_array_mutable(&q, line)?;
                        let arr_idx = self.chunk.intern_name(&q);
                        self.compile_expr(index)?;
                        self.emit_op(Op::Dup, line, Some(root));
                        self.emit_op(Op::GetArrayElem(arr_idx), line, Some(root));
                        self.emit_op(Op::LoadInt(1), line, Some(root));
                        self.emit_op(Op::Add, line, Some(root));
                        self.emit_op(Op::Dup, line, Some(root));
                        self.emit_op(Op::Rot, line, Some(root));
                        self.emit_op(Op::SetArrayElem(arr_idx), line, Some(root));
                    } else if let ExprKind::ArraySlice { array, indices } = &expr.kind {
                        if self.is_mysync_array(array) {
                            return Err(CompileError::Unsupported(
                                "mysync array element update".into(),
                            ));
                        }
                        self.check_strict_array_access(array, line)?;
                        let q = self.qualify_stash_array_name(array);
                        self.check_array_mutable(&q, line)?;
                        let arr_idx = self.chunk.intern_name(&q);
                        for ix in indices {
                            self.compile_array_slice_index_expr(ix)?;
                        }
                        self.emit_op(
                            Op::NamedArraySliceIncDec(0, arr_idx, indices.len() as u16),
                            line,
                            Some(root),
                        );
                    } else if let ExprKind::HashElement { hash, key } = &expr.kind {
                        if self.is_mysync_hash(hash) {
                            return Err(CompileError::Unsupported(
                                "mysync hash element update".into(),
                            ));
                        }
                        self.check_hash_mutable(hash, line)?;
                        let hash_idx = self.chunk.intern_name(hash);
                        self.compile_expr(key)?;
                        self.emit_op(Op::Dup, line, Some(root));
                        self.emit_op(Op::GetHashElem(hash_idx), line, Some(root));
                        self.emit_op(Op::LoadInt(1), line, Some(root));
                        self.emit_op(Op::Add, line, Some(root));
                        self.emit_op(Op::Dup, line, Some(root));
                        self.emit_op(Op::Rot, line, Some(root));
                        self.emit_op(Op::SetHashElem(hash_idx), line, Some(root));
                    } else if let ExprKind::HashSlice { hash, keys } = &expr.kind {
                        if self.is_mysync_hash(hash) {
                            return Err(CompileError::Unsupported(
                                "mysync hash element update".into(),
                            ));
                        }
                        self.check_hash_mutable(hash, line)?;
                        let hash_idx = self.chunk.intern_name(hash);
                        if hash_slice_needs_slice_ops(keys) {
                            for hk in keys {
                                self.compile_expr(hk)?;
                            }
                            self.emit_op(
                                Op::NamedHashSliceIncDec(0, hash_idx, keys.len() as u16),
                                line,
                                Some(root),
                            );
                            return Ok(());
                        }
                        let hk = &keys[0];
                        self.compile_expr(hk)?;
                        self.emit_op(Op::Dup, line, Some(root));
                        self.emit_op(Op::GetHashElem(hash_idx), line, Some(root));
                        self.emit_op(Op::LoadInt(1), line, Some(root));
                        self.emit_op(Op::Add, line, Some(root));
                        self.emit_op(Op::Dup, line, Some(root));
                        self.emit_op(Op::Rot, line, Some(root));
                        self.emit_op(Op::SetHashElem(hash_idx), line, Some(root));
                    } else if let ExprKind::ArrowDeref {
                        expr,
                        index,
                        kind: DerefKind::Array,
                    } = &expr.kind
                    {
                        if let ExprKind::List(indices) = &index.kind {
                            // Multi-index `++@$aref[i1,i2,...]` — delegates to VM slice inc-dec.
                            self.compile_arrow_array_base_expr(expr)?;
                            for ix in indices {
                                self.compile_array_slice_index_expr(ix)?;
                            }
                            self.emit_op(
                                Op::ArrowArraySliceIncDec(0, indices.len() as u16),
                                line,
                                Some(root),
                            );
                            return Ok(());
                        }
                        self.compile_arrow_array_base_expr(expr)?;
                        self.compile_array_slice_index_expr(index)?;
                        self.emit_op(Op::ArrowArraySliceIncDec(0, 1), line, Some(root));
                    } else if let ExprKind::AnonymousListSlice { source, indices } = &expr.kind {
                        if let ExprKind::Deref {
                            expr: inner,
                            kind: Sigil::Array,
                        } = &source.kind
                        {
                            self.compile_arrow_array_base_expr(inner)?;
                            for ix in indices {
                                self.compile_array_slice_index_expr(ix)?;
                            }
                            self.emit_op(
                                Op::ArrowArraySliceIncDec(0, indices.len() as u16),
                                line,
                                Some(root),
                            );
                            return Ok(());
                        }
                    } else if let ExprKind::ArrowDeref {
                        expr,
                        index,
                        kind: DerefKind::Hash,
                    } = &expr.kind
                    {
                        self.compile_arrow_hash_base_expr(expr)?;
                        self.compile_expr(index)?;
                        self.emit_op(Op::Dup2, line, Some(root));
                        self.emit_op(Op::ArrowHash, line, Some(root));
                        self.emit_op(Op::LoadInt(1), line, Some(root));
                        self.emit_op(Op::Add, line, Some(root));
                        self.emit_op(Op::Dup, line, Some(root));
                        self.emit_op(Op::Pop, line, Some(root));
                        self.emit_op(Op::Swap, line, Some(root));
                        self.emit_op(Op::Rot, line, Some(root));
                        self.emit_op(Op::Swap, line, Some(root));
                        self.emit_op(Op::SetArrowHashKeep, line, Some(root));
                    } else if let ExprKind::HashSliceDeref { container, keys } = &expr.kind {
                        if hash_slice_needs_slice_ops(keys) {
                            // Multi-key: matches generic PreIncrement fallback
                            // (list → int → ±1 → slice assign). Dedicated op in VM delegates to
                            // Interpreter::hash_slice_deref_inc_dec.
                            self.compile_expr(container)?;
                            for hk in keys {
                                self.compile_expr(hk)?;
                            }
                            self.emit_op(
                                Op::HashSliceDerefIncDec(0, keys.len() as u16),
                                line,
                                Some(root),
                            );
                            return Ok(());
                        }
                        let hk = &keys[0];
                        self.compile_expr(container)?;
                        self.compile_expr(hk)?;
                        self.emit_op(Op::Dup2, line, Some(root));
                        self.emit_op(Op::ArrowHash, line, Some(root));
                        self.emit_op(Op::LoadInt(1), line, Some(root));
                        self.emit_op(Op::Add, line, Some(root));
                        self.emit_op(Op::Dup, line, Some(root));
                        self.emit_op(Op::Pop, line, Some(root));
                        self.emit_op(Op::Swap, line, Some(root));
                        self.emit_op(Op::Rot, line, Some(root));
                        self.emit_op(Op::Swap, line, Some(root));
                        self.emit_op(Op::SetArrowHashKeep, line, Some(root));
                    } else if let ExprKind::Deref {
                        expr,
                        kind: Sigil::Scalar,
                    } = &expr.kind
                    {
                        self.compile_expr(expr)?;
                        self.emit_op(Op::Dup, line, Some(root));
                        self.emit_op(Op::SymbolicDeref(0), line, Some(root));
                        self.emit_op(Op::LoadInt(1), line, Some(root));
                        self.emit_op(Op::Add, line, Some(root));
                        self.emit_op(Op::Swap, line, Some(root));
                        self.emit_op(Op::SetSymbolicScalarRefKeep, line, Some(root));
                    } else if let ExprKind::Deref { kind, .. } = &expr.kind {
                        // `++@{…}` / `++%{…}` (and `++@$r` / `++%$r`) are invalid in Perl 5.
                        // Emit a runtime error directly so the VM produces the same error
                        // Perl would.
                        self.emit_aggregate_symbolic_inc_dec_error(*kind, true, true, line, root)?;
                    } else {
                        return Err(CompileError::Unsupported("PreInc on non-scalar".into()));
                    }
                }
                UnaryOp::PreDecrement => {
                    if let ExprKind::ScalarVar(name) = &expr.kind {
                        self.check_scalar_mutable(name, line)?;
                        self.check_closure_write_to_outer_my(name, line)?;
                        let idx = self.intern_scalar_var_for_ops(name);
                        self.emit_pre_dec(idx, line, Some(root));
                    } else if let ExprKind::ArrayElement { array, index } = &expr.kind {
                        if self.is_mysync_array(array) {
                            return Err(CompileError::Unsupported(
                                "mysync array element update".into(),
                            ));
                        }
                        let q = self.qualify_stash_array_name(array);
                        self.check_array_mutable(&q, line)?;
                        let arr_idx = self.chunk.intern_name(&q);
                        self.compile_expr(index)?;
                        self.emit_op(Op::Dup, line, Some(root));
                        self.emit_op(Op::GetArrayElem(arr_idx), line, Some(root));
                        self.emit_op(Op::LoadInt(1), line, Some(root));
                        self.emit_op(Op::Sub, line, Some(root));
                        self.emit_op(Op::Dup, line, Some(root));
                        self.emit_op(Op::Rot, line, Some(root));
                        self.emit_op(Op::SetArrayElem(arr_idx), line, Some(root));
                    } else if let ExprKind::ArraySlice { array, indices } = &expr.kind {
                        if self.is_mysync_array(array) {
                            return Err(CompileError::Unsupported(
                                "mysync array element update".into(),
                            ));
                        }
                        self.check_strict_array_access(array, line)?;
                        let q = self.qualify_stash_array_name(array);
                        self.check_array_mutable(&q, line)?;
                        let arr_idx = self.chunk.intern_name(&q);
                        for ix in indices {
                            self.compile_array_slice_index_expr(ix)?;
                        }
                        self.emit_op(
                            Op::NamedArraySliceIncDec(1, arr_idx, indices.len() as u16),
                            line,
                            Some(root),
                        );
                    } else if let ExprKind::HashElement { hash, key } = &expr.kind {
                        if self.is_mysync_hash(hash) {
                            return Err(CompileError::Unsupported(
                                "mysync hash element update".into(),
                            ));
                        }
                        self.check_hash_mutable(hash, line)?;
                        let hash_idx = self.chunk.intern_name(hash);
                        self.compile_expr(key)?;
                        self.emit_op(Op::Dup, line, Some(root));
                        self.emit_op(Op::GetHashElem(hash_idx), line, Some(root));
                        self.emit_op(Op::LoadInt(1), line, Some(root));
                        self.emit_op(Op::Sub, line, Some(root));
                        self.emit_op(Op::Dup, line, Some(root));
                        self.emit_op(Op::Rot, line, Some(root));
                        self.emit_op(Op::SetHashElem(hash_idx), line, Some(root));
                    } else if let ExprKind::HashSlice { hash, keys } = &expr.kind {
                        if self.is_mysync_hash(hash) {
                            return Err(CompileError::Unsupported(
                                "mysync hash element update".into(),
                            ));
                        }
                        self.check_hash_mutable(hash, line)?;
                        let hash_idx = self.chunk.intern_name(hash);
                        if hash_slice_needs_slice_ops(keys) {
                            for hk in keys {
                                self.compile_expr(hk)?;
                            }
                            self.emit_op(
                                Op::NamedHashSliceIncDec(1, hash_idx, keys.len() as u16),
                                line,
                                Some(root),
                            );
                            return Ok(());
                        }
                        let hk = &keys[0];
                        self.compile_expr(hk)?;
                        self.emit_op(Op::Dup, line, Some(root));
                        self.emit_op(Op::GetHashElem(hash_idx), line, Some(root));
                        self.emit_op(Op::LoadInt(1), line, Some(root));
                        self.emit_op(Op::Sub, line, Some(root));
                        self.emit_op(Op::Dup, line, Some(root));
                        self.emit_op(Op::Rot, line, Some(root));
                        self.emit_op(Op::SetHashElem(hash_idx), line, Some(root));
                    } else if let ExprKind::ArrowDeref {
                        expr,
                        index,
                        kind: DerefKind::Array,
                    } = &expr.kind
                    {
                        if let ExprKind::List(indices) = &index.kind {
                            self.compile_arrow_array_base_expr(expr)?;
                            for ix in indices {
                                self.compile_array_slice_index_expr(ix)?;
                            }
                            self.emit_op(
                                Op::ArrowArraySliceIncDec(1, indices.len() as u16),
                                line,
                                Some(root),
                            );
                            return Ok(());
                        }
                        self.compile_arrow_array_base_expr(expr)?;
                        self.compile_array_slice_index_expr(index)?;
                        self.emit_op(Op::ArrowArraySliceIncDec(1, 1), line, Some(root));
                    } else if let ExprKind::AnonymousListSlice { source, indices } = &expr.kind {
                        if let ExprKind::Deref {
                            expr: inner,
                            kind: Sigil::Array,
                        } = &source.kind
                        {
                            self.compile_arrow_array_base_expr(inner)?;
                            for ix in indices {
                                self.compile_array_slice_index_expr(ix)?;
                            }
                            self.emit_op(
                                Op::ArrowArraySliceIncDec(1, indices.len() as u16),
                                line,
                                Some(root),
                            );
                            return Ok(());
                        }
                    } else if let ExprKind::ArrowDeref {
                        expr,
                        index,
                        kind: DerefKind::Hash,
                    } = &expr.kind
                    {
                        self.compile_arrow_hash_base_expr(expr)?;
                        self.compile_expr(index)?;
                        self.emit_op(Op::Dup2, line, Some(root));
                        self.emit_op(Op::ArrowHash, line, Some(root));
                        self.emit_op(Op::LoadInt(1), line, Some(root));
                        self.emit_op(Op::Sub, line, Some(root));
                        self.emit_op(Op::Dup, line, Some(root));
                        self.emit_op(Op::Pop, line, Some(root));
                        self.emit_op(Op::Swap, line, Some(root));
                        self.emit_op(Op::Rot, line, Some(root));
                        self.emit_op(Op::Swap, line, Some(root));
                        self.emit_op(Op::SetArrowHashKeep, line, Some(root));
                    } else if let ExprKind::HashSliceDeref { container, keys } = &expr.kind {
                        if hash_slice_needs_slice_ops(keys) {
                            self.compile_expr(container)?;
                            for hk in keys {
                                self.compile_expr(hk)?;
                            }
                            self.emit_op(
                                Op::HashSliceDerefIncDec(1, keys.len() as u16),
                                line,
                                Some(root),
                            );
                            return Ok(());
                        }
                        let hk = &keys[0];
                        self.compile_expr(container)?;
                        self.compile_expr(hk)?;
                        self.emit_op(Op::Dup2, line, Some(root));
                        self.emit_op(Op::ArrowHash, line, Some(root));
                        self.emit_op(Op::LoadInt(1), line, Some(root));
                        self.emit_op(Op::Sub, line, Some(root));
                        self.emit_op(Op::Dup, line, Some(root));
                        self.emit_op(Op::Pop, line, Some(root));
                        self.emit_op(Op::Swap, line, Some(root));
                        self.emit_op(Op::Rot, line, Some(root));
                        self.emit_op(Op::Swap, line, Some(root));
                        self.emit_op(Op::SetArrowHashKeep, line, Some(root));
                    } else if let ExprKind::Deref {
                        expr,
                        kind: Sigil::Scalar,
                    } = &expr.kind
                    {
                        self.compile_expr(expr)?;
                        self.emit_op(Op::Dup, line, Some(root));
                        self.emit_op(Op::SymbolicDeref(0), line, Some(root));
                        self.emit_op(Op::LoadInt(1), line, Some(root));
                        self.emit_op(Op::Sub, line, Some(root));
                        self.emit_op(Op::Swap, line, Some(root));
                        self.emit_op(Op::SetSymbolicScalarRefKeep, line, Some(root));
                    } else if let ExprKind::Deref { kind, .. } = &expr.kind {
                        self.emit_aggregate_symbolic_inc_dec_error(*kind, true, false, line, root)?;
                    } else {
                        return Err(CompileError::Unsupported("PreDec on non-scalar".into()));
                    }
                }
                UnaryOp::Ref => {
                    self.compile_expr(expr)?;
                    self.emit_op(Op::MakeScalarRef, line, Some(root));
                }
                _ => match op {
                    UnaryOp::LogNot | UnaryOp::LogNotWord => {
                        if matches!(expr.kind, ExprKind::Regex(..)) {
                            self.compile_boolean_rvalue_condition(expr)?;
                        } else {
                            self.compile_expr(expr)?;
                        }
                        self.emit_op(Op::LogNot, line, Some(root));
                    }
                    UnaryOp::Negate => {
                        self.compile_expr(expr)?;
                        self.emit_op(Op::Negate, line, Some(root));
                    }
                    UnaryOp::BitNot => {
                        self.compile_expr(expr)?;
                        self.emit_op(Op::BitNot, line, Some(root));
                    }
                    _ => unreachable!(),
                },
            },
            ExprKind::PostfixOp { expr, op } => {
                if let ExprKind::ScalarVar(name) = &expr.kind {
                    self.check_scalar_mutable(name, line)?;
                    self.check_closure_write_to_outer_my(name, line)?;
                    let idx = self.intern_scalar_var_for_ops(name);
                    match op {
                        PostfixOp::Increment => {
                            self.emit_post_inc(idx, line, Some(root));
                        }
                        PostfixOp::Decrement => {
                            self.emit_post_dec(idx, line, Some(root));
                        }
                    }
                } else if let ExprKind::ArrayElement { array, index } = &expr.kind {
                    if self.is_mysync_array(array) {
                        return Err(CompileError::Unsupported(
                            "mysync array element update".into(),
                        ));
                    }
                    let q = self.qualify_stash_array_name(array);
                    self.check_array_mutable(&q, line)?;
                    let arr_idx = self.chunk.intern_name(&q);
                    self.compile_expr(index)?;
                    self.emit_op(Op::Dup, line, Some(root));
                    self.emit_op(Op::GetArrayElem(arr_idx), line, Some(root));
                    self.emit_op(Op::Dup, line, Some(root));
                    self.emit_op(Op::LoadInt(1), line, Some(root));
                    match op {
                        PostfixOp::Increment => {
                            self.emit_op(Op::Add, line, Some(root));
                        }
                        PostfixOp::Decrement => {
                            self.emit_op(Op::Sub, line, Some(root));
                        }
                    }
                    self.emit_op(Op::Rot, line, Some(root));
                    self.emit_op(Op::SetArrayElem(arr_idx), line, Some(root));
                } else if let ExprKind::ArraySlice { array, indices } = &expr.kind {
                    if self.is_mysync_array(array) {
                        return Err(CompileError::Unsupported(
                            "mysync array element update".into(),
                        ));
                    }
                    self.check_strict_array_access(array, line)?;
                    let q = self.qualify_stash_array_name(array);
                    self.check_array_mutable(&q, line)?;
                    let arr_idx = self.chunk.intern_name(&q);
                    let kind_byte: u8 = match op {
                        PostfixOp::Increment => 2,
                        PostfixOp::Decrement => 3,
                    };
                    for ix in indices {
                        self.compile_array_slice_index_expr(ix)?;
                    }
                    self.emit_op(
                        Op::NamedArraySliceIncDec(kind_byte, arr_idx, indices.len() as u16),
                        line,
                        Some(root),
                    );
                } else if let ExprKind::HashElement { hash, key } = &expr.kind {
                    if self.is_mysync_hash(hash) {
                        return Err(CompileError::Unsupported(
                            "mysync hash element update".into(),
                        ));
                    }
                    self.check_hash_mutable(hash, line)?;
                    let hash_idx = self.chunk.intern_name(hash);
                    self.compile_expr(key)?;
                    self.emit_op(Op::Dup, line, Some(root));
                    self.emit_op(Op::GetHashElem(hash_idx), line, Some(root));
                    self.emit_op(Op::Dup, line, Some(root));
                    self.emit_op(Op::LoadInt(1), line, Some(root));
                    match op {
                        PostfixOp::Increment => {
                            self.emit_op(Op::Add, line, Some(root));
                        }
                        PostfixOp::Decrement => {
                            self.emit_op(Op::Sub, line, Some(root));
                        }
                    }
                    self.emit_op(Op::Rot, line, Some(root));
                    self.emit_op(Op::SetHashElem(hash_idx), line, Some(root));
                } else if let ExprKind::HashSlice { hash, keys } = &expr.kind {
                    if self.is_mysync_hash(hash) {
                        return Err(CompileError::Unsupported(
                            "mysync hash element update".into(),
                        ));
                    }
                    self.check_hash_mutable(hash, line)?;
                    let hash_idx = self.chunk.intern_name(hash);
                    if hash_slice_needs_slice_ops(keys) {
                        let kind_byte: u8 = match op {
                            PostfixOp::Increment => 2,
                            PostfixOp::Decrement => 3,
                        };
                        for hk in keys {
                            self.compile_expr(hk)?;
                        }
                        self.emit_op(
                            Op::NamedHashSliceIncDec(kind_byte, hash_idx, keys.len() as u16),
                            line,
                            Some(root),
                        );
                        return Ok(());
                    }
                    let hk = &keys[0];
                    self.compile_expr(hk)?;
                    self.emit_op(Op::Dup, line, Some(root));
                    self.emit_op(Op::GetHashElem(hash_idx), line, Some(root));
                    self.emit_op(Op::Dup, line, Some(root));
                    self.emit_op(Op::LoadInt(1), line, Some(root));
                    match op {
                        PostfixOp::Increment => {
                            self.emit_op(Op::Add, line, Some(root));
                        }
                        PostfixOp::Decrement => {
                            self.emit_op(Op::Sub, line, Some(root));
                        }
                    }
                    self.emit_op(Op::Rot, line, Some(root));
                    self.emit_op(Op::SetHashElem(hash_idx), line, Some(root));
                } else if let ExprKind::ArrowDeref {
                    expr: inner,
                    index,
                    kind: DerefKind::Array,
                } = &expr.kind
                {
                    if let ExprKind::List(indices) = &index.kind {
                        let kind_byte: u8 = match op {
                            PostfixOp::Increment => 2,
                            PostfixOp::Decrement => 3,
                        };
                        self.compile_arrow_array_base_expr(inner)?;
                        for ix in indices {
                            self.compile_array_slice_index_expr(ix)?;
                        }
                        self.emit_op(
                            Op::ArrowArraySliceIncDec(kind_byte, indices.len() as u16),
                            line,
                            Some(root),
                        );
                        return Ok(());
                    }
                    self.compile_arrow_array_base_expr(inner)?;
                    self.compile_array_slice_index_expr(index)?;
                    let kind_byte: u8 = match op {
                        PostfixOp::Increment => 2,
                        PostfixOp::Decrement => 3,
                    };
                    self.emit_op(Op::ArrowArraySliceIncDec(kind_byte, 1), line, Some(root));
                } else if let ExprKind::AnonymousListSlice { source, indices } = &expr.kind {
                    let ExprKind::Deref {
                        expr: inner,
                        kind: Sigil::Array,
                    } = &source.kind
                    else {
                        return Err(CompileError::Unsupported(
                            "PostfixOp on list slice (non-array deref)".into(),
                        ));
                    };
                    if indices.is_empty() {
                        return Err(CompileError::Unsupported(
                            "postfix ++/-- on empty list slice (internal)".into(),
                        ));
                    }
                    let kind_byte: u8 = match op {
                        PostfixOp::Increment => 2,
                        PostfixOp::Decrement => 3,
                    };
                    self.compile_arrow_array_base_expr(inner)?;
                    if indices.len() > 1 {
                        for ix in indices {
                            self.compile_array_slice_index_expr(ix)?;
                        }
                        self.emit_op(
                            Op::ArrowArraySliceIncDec(kind_byte, indices.len() as u16),
                            line,
                            Some(root),
                        );
                    } else {
                        self.compile_array_slice_index_expr(&indices[0])?;
                        self.emit_op(Op::ArrowArraySliceIncDec(kind_byte, 1), line, Some(root));
                    }
                } else if let ExprKind::ArrowDeref {
                    expr: inner,
                    index,
                    kind: DerefKind::Hash,
                } = &expr.kind
                {
                    self.compile_arrow_hash_base_expr(inner)?;
                    self.compile_expr(index)?;
                    let b = match op {
                        PostfixOp::Increment => 0u8,
                        PostfixOp::Decrement => 1u8,
                    };
                    self.emit_op(Op::ArrowHashPostfix(b), line, Some(root));
                } else if let ExprKind::HashSliceDeref { container, keys } = &expr.kind {
                    if hash_slice_needs_slice_ops(keys) {
                        // Multi-key postfix ++/--: matches generic PostfixOp fallback
                        // (reads slice list, assigns scalar back, returns old list).
                        let kind_byte: u8 = match op {
                            PostfixOp::Increment => 2,
                            PostfixOp::Decrement => 3,
                        };
                        self.compile_expr(container)?;
                        for hk in keys {
                            self.compile_expr(hk)?;
                        }
                        self.emit_op(
                            Op::HashSliceDerefIncDec(kind_byte, keys.len() as u16),
                            line,
                            Some(root),
                        );
                        return Ok(());
                    }
                    let hk = &keys[0];
                    self.compile_expr(container)?;
                    self.compile_expr(hk)?;
                    let b = match op {
                        PostfixOp::Increment => 0u8,
                        PostfixOp::Decrement => 1u8,
                    };
                    self.emit_op(Op::ArrowHashPostfix(b), line, Some(root));
                } else if let ExprKind::Deref {
                    expr,
                    kind: Sigil::Scalar,
                } = &expr.kind
                {
                    self.compile_expr(expr)?;
                    let b = match op {
                        PostfixOp::Increment => 0u8,
                        PostfixOp::Decrement => 1u8,
                    };
                    self.emit_op(Op::SymbolicScalarRefPostfix(b), line, Some(root));
                } else if let ExprKind::Deref { kind, .. } = &expr.kind {
                    let is_inc = matches!(op, PostfixOp::Increment);
                    self.emit_aggregate_symbolic_inc_dec_error(*kind, false, is_inc, line, root)?;
                } else {
                    return Err(CompileError::Unsupported("PostfixOp on non-scalar".into()));
                }
            }

            ExprKind::Assign { target, value } => {
                // `substr($s, $o, $l) = $rhs` is equivalent to the 4-arg
                // form `substr($s, $o, $l, $rhs)`. Rewrite + compile as
                // a function call so the dedicated lvalue path isn't
                // needed.
                if let ExprKind::Substr {
                    string,
                    offset,
                    length,
                    replacement: None,
                } = &target.kind
                {
                    let rewritten = Expr {
                        kind: ExprKind::Substr {
                            string: string.clone(),
                            offset: offset.clone(),
                            length: length.clone(),
                            replacement: Some(value.clone()),
                        },
                        line: target.line,
                    };
                    self.compile_expr(&rewritten)?;
                    return Ok(());
                }
                // `vec($s, $o, $b) = $rhs` — set the requested bit field
                // in $s and write back. Lower to:
                //     $s = vec_set_value($s, $o, $b, $rhs);
                // where `vec_set_value` is a 4-arg pure builtin that
                // returns the modified string. This lets every supported
                // lvalue shape for `$s` (plain scalar, array element,
                // hash element, etc.) reuse its existing assign path.
                if let ExprKind::FuncCall { name, args } = &target.kind {
                    if name == "vec" && args.len() == 3 {
                        let new_call = Expr {
                            kind: ExprKind::FuncCall {
                                name: "vec_set_value".to_string(),
                                args: vec![
                                    args[0].clone(),
                                    args[1].clone(),
                                    args[2].clone(),
                                    (**value).clone(),
                                ],
                            },
                            line: target.line,
                        };
                        let rewritten = Expr {
                            kind: ExprKind::Assign {
                                target: Box::new(args[0].clone()),
                                value: Box::new(new_call),
                            },
                            line,
                        };
                        self.compile_expr(&rewritten)?;
                        return Ok(());
                    }
                }
                if let (ExprKind::Typeglob(lhs), ExprKind::Typeglob(rhs)) =
                    (&target.kind, &value.kind)
                {
                    let lhs_idx = self.chunk.intern_name(lhs);
                    let rhs_idx = self.chunk.intern_name(rhs);
                    self.emit_op(Op::CopyTypeglobSlots(lhs_idx, rhs_idx), line, Some(root));
                    self.compile_expr(value)?;
                    return Ok(());
                }
                if let ExprKind::TypeglobExpr(expr) = &target.kind {
                    if let ExprKind::Typeglob(rhs) = &value.kind {
                        self.compile_expr(expr)?;
                        let rhs_idx = self.chunk.intern_name(rhs);
                        self.emit_op(Op::CopyTypeglobSlotsDynamicLhs(rhs_idx), line, Some(root));
                        self.compile_expr(value)?;
                        return Ok(());
                    }
                    self.compile_expr(expr)?;
                    self.compile_expr(value)?;
                    self.emit_op(Op::TypeglobAssignFromValueDynamic, line, Some(root));
                    return Ok(());
                }
                // Braced `*{EXPR}` parses as `Deref { kind: Typeglob }` (same VM lowering as `TypeglobExpr`).
                if let ExprKind::Deref {
                    expr,
                    kind: Sigil::Typeglob,
                } = &target.kind
                {
                    if let ExprKind::Typeglob(rhs) = &value.kind {
                        self.compile_expr(expr)?;
                        let rhs_idx = self.chunk.intern_name(rhs);
                        self.emit_op(Op::CopyTypeglobSlotsDynamicLhs(rhs_idx), line, Some(root));
                        self.compile_expr(value)?;
                        return Ok(());
                    }
                    self.compile_expr(expr)?;
                    self.compile_expr(value)?;
                    self.emit_op(Op::TypeglobAssignFromValueDynamic, line, Some(root));
                    return Ok(());
                }
                if let ExprKind::ArrowDeref {
                    expr,
                    index,
                    kind: DerefKind::Array,
                } = &target.kind
                {
                    if let ExprKind::List(indices) = &index.kind {
                        if let ExprKind::Deref {
                            expr: inner,
                            kind: Sigil::Array,
                        } = &expr.kind
                        {
                            if let ExprKind::List(vals) = &value.kind {
                                if !indices.is_empty() && indices.len() == vals.len() {
                                    for (idx_e, val_e) in indices.iter().zip(vals.iter()) {
                                        self.compile_expr(val_e)?;
                                        self.compile_expr(inner)?;
                                        self.compile_expr(idx_e)?;
                                        self.emit_op(Op::SetArrowArray, line, Some(root));
                                    }
                                    return Ok(());
                                }
                            }
                        }
                    }
                }
                // Fuse `$x = $x OP $y` / `$x = $x + 1` into slot ops when possible.
                if let ExprKind::ScalarVar(tgt_name) = &target.kind {
                    if let Some(dst_slot) = self.scalar_slot(tgt_name) {
                        if let ExprKind::BinOp { left, op, right } = &value.kind {
                            if let ExprKind::ScalarVar(lv) = &left.kind {
                                if lv == tgt_name {
                                    // $x = $x + SCALAR_VAR → AddAssignSlotSlot etc.
                                    if let ExprKind::ScalarVar(rv) = &right.kind {
                                        if let Some(src_slot) = self.scalar_slot(rv) {
                                            let fused = match op {
                                                BinOp::Add => {
                                                    Some(Op::AddAssignSlotSlot(dst_slot, src_slot))
                                                }
                                                BinOp::Sub => {
                                                    Some(Op::SubAssignSlotSlot(dst_slot, src_slot))
                                                }
                                                BinOp::Mul => {
                                                    Some(Op::MulAssignSlotSlot(dst_slot, src_slot))
                                                }
                                                _ => None,
                                            };
                                            if let Some(fop) = fused {
                                                self.emit_op(fop, line, Some(root));
                                                return Ok(());
                                            }
                                        }
                                    }
                                    // $x = $x + 1 → PreIncSlot, $x = $x - 1 → PreDecSlot
                                    if let ExprKind::Integer(1) = &right.kind {
                                        match op {
                                            BinOp::Add => {
                                                self.emit_op(
                                                    Op::PreIncSlot(dst_slot),
                                                    line,
                                                    Some(root),
                                                );
                                                return Ok(());
                                            }
                                            BinOp::Sub => {
                                                self.emit_op(
                                                    Op::PreDecSlot(dst_slot),
                                                    line,
                                                    Some(root),
                                                );
                                                return Ok(());
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                self.compile_expr_ctx(value, assign_rhs_wantarray(target))?;
                self.compile_assign(target, line, true, Some(root))?;
            }
            ExprKind::CompoundAssign { target, op, value } => {
                if let ExprKind::ScalarVar(name) = &target.kind {
                    self.check_scalar_mutable(name, line)?;
                    let idx = self.intern_scalar_var_for_ops(name);
                    // Fast path: `.=` on scalar → in-place append (no clone)
                    if *op == BinOp::Concat {
                        self.compile_expr(value)?;
                        if let Some(slot) = self.scalar_slot(name) {
                            self.emit_op(Op::ConcatAppendSlot(slot), line, Some(root));
                        } else {
                            self.emit_op(Op::ConcatAppend(idx), line, Some(root));
                        }
                        return Ok(());
                    }
                    // Fused slot+slot arithmetic: $slot_a += $slot_b (no stack traffic)
                    if let Some(dst_slot) = self.scalar_slot(name) {
                        if let ExprKind::ScalarVar(rhs_name) = &value.kind {
                            if let Some(src_slot) = self.scalar_slot(rhs_name) {
                                let fused = match op {
                                    BinOp::Add => Some(Op::AddAssignSlotSlot(dst_slot, src_slot)),
                                    BinOp::Sub => Some(Op::SubAssignSlotSlot(dst_slot, src_slot)),
                                    BinOp::Mul => Some(Op::MulAssignSlotSlot(dst_slot, src_slot)),
                                    _ => None,
                                };
                                if let Some(fop) = fused {
                                    self.emit_op(fop, line, Some(root));
                                    return Ok(());
                                }
                            }
                        }
                    }
                    if *op == BinOp::DefinedOr {
                        // `$x //=` — short-circuit when LHS is defined.
                        // Slot-aware: use GetScalarSlot/SetScalarSlot if available.
                        if let Some(slot) = self.scalar_slot(name) {
                            self.emit_op(Op::GetScalarSlot(slot), line, Some(root));
                            let j_def = self.emit_op(Op::JumpIfDefinedKeep(0), line, Some(root));
                            self.compile_expr(value)?;
                            self.emit_op(Op::Dup, line, Some(root));
                            self.emit_op(Op::SetScalarSlot(slot), line, Some(root));
                            let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                            self.chunk.patch_jump_here(j_def);
                            self.chunk.patch_jump_here(j_end);
                        } else {
                            self.emit_get_scalar(idx, line, Some(root));
                            let j_def = self.emit_op(Op::JumpIfDefinedKeep(0), line, Some(root));
                            self.compile_expr(value)?;
                            self.emit_set_scalar_keep(idx, line, Some(root));
                            let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                            self.chunk.patch_jump_here(j_def);
                            self.chunk.patch_jump_here(j_end);
                        }
                        return Ok(());
                    }
                    if *op == BinOp::LogOr {
                        // `$x ||=` — short-circuit when LHS is true.
                        if let Some(slot) = self.scalar_slot(name) {
                            self.emit_op(Op::GetScalarSlot(slot), line, Some(root));
                            let j_true = self.emit_op(Op::JumpIfTrueKeep(0), line, Some(root));
                            self.compile_expr(value)?;
                            self.emit_op(Op::Dup, line, Some(root));
                            self.emit_op(Op::SetScalarSlot(slot), line, Some(root));
                            let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                            self.chunk.patch_jump_here(j_true);
                            self.chunk.patch_jump_here(j_end);
                        } else {
                            self.emit_get_scalar(idx, line, Some(root));
                            let j_true = self.emit_op(Op::JumpIfTrueKeep(0), line, Some(root));
                            self.compile_expr(value)?;
                            self.emit_set_scalar_keep(idx, line, Some(root));
                            let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                            self.chunk.patch_jump_here(j_true);
                            self.chunk.patch_jump_here(j_end);
                        }
                        return Ok(());
                    }
                    if *op == BinOp::LogAnd {
                        // `$x &&=` — short-circuit when LHS is false.
                        if let Some(slot) = self.scalar_slot(name) {
                            self.emit_op(Op::GetScalarSlot(slot), line, Some(root));
                            let j = self.emit_op(Op::JumpIfFalseKeep(0), line, Some(root));
                            self.compile_expr(value)?;
                            self.emit_op(Op::Dup, line, Some(root));
                            self.emit_op(Op::SetScalarSlot(slot), line, Some(root));
                            let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                            self.chunk.patch_jump_here(j);
                            self.chunk.patch_jump_here(j_end);
                        } else {
                            self.emit_get_scalar(idx, line, Some(root));
                            let j = self.emit_op(Op::JumpIfFalseKeep(0), line, Some(root));
                            self.compile_expr(value)?;
                            self.emit_set_scalar_keep(idx, line, Some(root));
                            let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                            self.chunk.patch_jump_here(j);
                            self.chunk.patch_jump_here(j_end);
                        }
                        return Ok(());
                    }
                    if let Some(op_b) = scalar_compound_op_to_byte(*op) {
                        // Slot-aware path: `my $x` inside a sub body lives in a local slot.
                        if let Some(slot) = self.scalar_slot(name) {
                            let vm_op = binop_to_vm_op(*op).ok_or_else(|| {
                                CompileError::Unsupported("CompoundAssign op (slot)".into())
                            })?;
                            self.emit_op(Op::GetScalarSlot(slot), line, Some(root));
                            self.compile_expr(value)?;
                            self.emit_op(vm_op, line, Some(root));
                            self.emit_op(Op::Dup, line, Some(root));
                            self.emit_op(Op::SetScalarSlot(slot), line, Some(root));
                            return Ok(());
                        }
                        self.compile_expr(value)?;
                        self.emit_op(
                            Op::ScalarCompoundAssign {
                                name_idx: idx,
                                op: op_b,
                            },
                            line,
                            Some(root),
                        );
                    } else {
                        return Err(CompileError::Unsupported("CompoundAssign op".into()));
                    }
                } else if let ExprKind::ArrayElement { array, index } = &target.kind {
                    if self.is_mysync_array(array) {
                        return Err(CompileError::Unsupported(
                            "mysync array element update".into(),
                        ));
                    }
                    let q = self.qualify_stash_array_name(array);
                    self.check_array_mutable(&q, line)?;
                    let arr_idx = self.chunk.intern_name(&q);
                    match op {
                        BinOp::DefinedOr | BinOp::LogOr | BinOp::LogAnd => {
                            self.compile_expr(index)?;
                            self.emit_op(Op::Dup, line, Some(root));
                            self.emit_op(Op::GetArrayElem(arr_idx), line, Some(root));
                            let j = match *op {
                                BinOp::DefinedOr => {
                                    self.emit_op(Op::JumpIfDefinedKeep(0), line, Some(root))
                                }
                                BinOp::LogOr => {
                                    self.emit_op(Op::JumpIfTrueKeep(0), line, Some(root))
                                }
                                BinOp::LogAnd => {
                                    self.emit_op(Op::JumpIfFalseKeep(0), line, Some(root))
                                }
                                _ => unreachable!(),
                            };
                            self.compile_expr(value)?;
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::SetArrayElemKeep(arr_idx), line, Some(root));
                            let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                            self.chunk.patch_jump_here(j);
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::Pop, line, Some(root));
                            self.chunk.patch_jump_here(j_end);
                        }
                        _ => {
                            let vm_op = binop_to_vm_op(*op).ok_or_else(|| {
                                CompileError::Unsupported("CompoundAssign op".into())
                            })?;
                            self.compile_expr(index)?;
                            self.emit_op(Op::Dup, line, Some(root));
                            self.emit_op(Op::GetArrayElem(arr_idx), line, Some(root));
                            self.compile_expr(value)?;
                            self.emit_op(vm_op, line, Some(root));
                            self.emit_op(Op::Dup, line, Some(root));
                            self.emit_op(Op::Rot, line, Some(root));
                            self.emit_op(Op::SetArrayElem(arr_idx), line, Some(root));
                        }
                    }
                } else if let ExprKind::HashElement { hash, key } = &target.kind {
                    if self.is_mysync_hash(hash) {
                        return Err(CompileError::Unsupported(
                            "mysync hash element update".into(),
                        ));
                    }
                    self.check_hash_mutable(hash, line)?;
                    let hash_idx = self.chunk.intern_name(hash);
                    match op {
                        BinOp::DefinedOr | BinOp::LogOr | BinOp::LogAnd => {
                            self.compile_expr(key)?;
                            self.emit_op(Op::Dup, line, Some(root));
                            self.emit_op(Op::GetHashElem(hash_idx), line, Some(root));
                            let j = match *op {
                                BinOp::DefinedOr => {
                                    self.emit_op(Op::JumpIfDefinedKeep(0), line, Some(root))
                                }
                                BinOp::LogOr => {
                                    self.emit_op(Op::JumpIfTrueKeep(0), line, Some(root))
                                }
                                BinOp::LogAnd => {
                                    self.emit_op(Op::JumpIfFalseKeep(0), line, Some(root))
                                }
                                _ => unreachable!(),
                            };
                            self.compile_expr(value)?;
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::SetHashElemKeep(hash_idx), line, Some(root));
                            let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                            self.chunk.patch_jump_here(j);
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::Pop, line, Some(root));
                            self.chunk.patch_jump_here(j_end);
                        }
                        _ => {
                            let vm_op = binop_to_vm_op(*op).ok_or_else(|| {
                                CompileError::Unsupported("CompoundAssign op".into())
                            })?;
                            self.compile_expr(key)?;
                            self.emit_op(Op::Dup, line, Some(root));
                            self.emit_op(Op::GetHashElem(hash_idx), line, Some(root));
                            self.compile_expr(value)?;
                            self.emit_op(vm_op, line, Some(root));
                            self.emit_op(Op::Dup, line, Some(root));
                            self.emit_op(Op::Rot, line, Some(root));
                            self.emit_op(Op::SetHashElem(hash_idx), line, Some(root));
                        }
                    }
                } else if let ExprKind::Deref {
                    expr,
                    kind: Sigil::Scalar,
                } = &target.kind
                {
                    match op {
                        BinOp::DefinedOr => {
                            // `$$r //=` — unlike binary `//`, no `Pop` after `JumpIfDefinedKeep`
                            // (the ref must stay under the deref); `Swap` before set (ref on TOS).
                            self.compile_expr(expr)?;
                            self.emit_op(Op::Dup, line, Some(root));
                            self.emit_op(Op::SymbolicDeref(0), line, Some(root));
                            let j_def = self.emit_op(Op::JumpIfDefinedKeep(0), line, Some(root));
                            self.compile_expr(value)?;
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::SetSymbolicScalarRefKeep, line, Some(root));
                            let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                            self.chunk.patch_jump_here(j_def);
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::Pop, line, Some(root));
                            self.chunk.patch_jump_here(j_end);
                        }
                        BinOp::LogOr => {
                            // `$$r ||=` — same idea as `//=`: no `Pop` after `JumpIfTrueKeep`.
                            self.compile_expr(expr)?;
                            self.emit_op(Op::Dup, line, Some(root));
                            self.emit_op(Op::SymbolicDeref(0), line, Some(root));
                            let j_true = self.emit_op(Op::JumpIfTrueKeep(0), line, Some(root));
                            self.compile_expr(value)?;
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::SetSymbolicScalarRefKeep, line, Some(root));
                            let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                            self.chunk.patch_jump_here(j_true);
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::Pop, line, Some(root));
                            self.chunk.patch_jump_here(j_end);
                        }
                        BinOp::LogAnd => {
                            // `$$r &&=` — no `Pop` after `JumpIfFalseKeep` (ref under LHS).
                            self.compile_expr(expr)?;
                            self.emit_op(Op::Dup, line, Some(root));
                            self.emit_op(Op::SymbolicDeref(0), line, Some(root));
                            let j = self.emit_op(Op::JumpIfFalseKeep(0), line, Some(root));
                            self.compile_expr(value)?;
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::SetSymbolicScalarRefKeep, line, Some(root));
                            let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                            self.chunk.patch_jump_here(j);
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::Pop, line, Some(root));
                            self.chunk.patch_jump_here(j_end);
                        }
                        _ => {
                            let vm_op = binop_to_vm_op(*op).ok_or_else(|| {
                                CompileError::Unsupported("CompoundAssign op".into())
                            })?;
                            self.compile_expr(expr)?;
                            self.emit_op(Op::Dup, line, Some(root));
                            self.emit_op(Op::SymbolicDeref(0), line, Some(root));
                            self.compile_expr(value)?;
                            self.emit_op(vm_op, line, Some(root));
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::SetSymbolicScalarRef, line, Some(root));
                        }
                    }
                } else if let ExprKind::ArrowDeref {
                    expr,
                    index,
                    kind: DerefKind::Hash,
                } = &target.kind
                {
                    match op {
                        BinOp::DefinedOr | BinOp::LogOr | BinOp::LogAnd => {
                            self.compile_arrow_hash_base_expr(expr)?;
                            self.compile_expr(index)?;
                            self.emit_op(Op::Dup2, line, Some(root));
                            self.emit_op(Op::ArrowHash, line, Some(root));
                            let j = match *op {
                                BinOp::DefinedOr => {
                                    self.emit_op(Op::JumpIfDefinedKeep(0), line, Some(root))
                                }
                                BinOp::LogOr => {
                                    self.emit_op(Op::JumpIfTrueKeep(0), line, Some(root))
                                }
                                BinOp::LogAnd => {
                                    self.emit_op(Op::JumpIfFalseKeep(0), line, Some(root))
                                }
                                _ => unreachable!(),
                            };
                            self.compile_expr(value)?;
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::Rot, line, Some(root));
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::SetArrowHashKeep, line, Some(root));
                            let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                            self.chunk.patch_jump_here(j);
                            // Stack: ref, key, cur — leave `cur` as the expression value.
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::Pop, line, Some(root));
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::Pop, line, Some(root));
                            self.chunk.patch_jump_here(j_end);
                        }
                        _ => {
                            let vm_op = binop_to_vm_op(*op).ok_or_else(|| {
                                CompileError::Unsupported("CompoundAssign op".into())
                            })?;
                            self.compile_arrow_hash_base_expr(expr)?;
                            self.compile_expr(index)?;
                            self.emit_op(Op::Dup2, line, Some(root));
                            self.emit_op(Op::ArrowHash, line, Some(root));
                            self.compile_expr(value)?;
                            self.emit_op(vm_op, line, Some(root));
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::Rot, line, Some(root));
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::SetArrowHash, line, Some(root));
                        }
                    }
                } else if let ExprKind::ArrowDeref {
                    expr,
                    index,
                    kind: DerefKind::Array,
                } = &target.kind
                {
                    if let ExprKind::List(indices) = &index.kind {
                        if matches!(op, BinOp::DefinedOr | BinOp::LogOr | BinOp::LogAnd) {
                            let k = indices.len() as u16;
                            self.compile_arrow_array_base_expr(expr)?;
                            for ix in indices {
                                self.compile_array_slice_index_expr(ix)?;
                            }
                            self.emit_op(Op::ArrowArraySlicePeekLast(k), line, Some(root));
                            let j = match *op {
                                BinOp::DefinedOr => {
                                    self.emit_op(Op::JumpIfDefinedKeep(0), line, Some(root))
                                }
                                BinOp::LogOr => {
                                    self.emit_op(Op::JumpIfTrueKeep(0), line, Some(root))
                                }
                                BinOp::LogAnd => {
                                    self.emit_op(Op::JumpIfFalseKeep(0), line, Some(root))
                                }
                                _ => unreachable!(),
                            };
                            self.compile_expr(value)?;
                            self.emit_op(Op::ArrowArraySliceRollValUnderSpecs(k), line, Some(root));
                            self.emit_op(Op::SetArrowArraySliceLastKeep(k), line, Some(root));
                            let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                            self.chunk.patch_jump_here(j);
                            self.emit_op(Op::ArrowArraySliceDropKeysKeepCur(k), line, Some(root));
                            self.chunk.patch_jump_here(j_end);
                            return Ok(());
                        }
                        // Multi-index `@$aref[i1,i2,...] OP= EXPR` — Perl applies the op only to the
                        // last index (see `Interpreter::compound_assign_arrow_array_slice`).
                        let op_byte = scalar_compound_op_to_byte(*op).ok_or_else(|| {
                            CompileError::Unsupported(
                                "CompoundAssign op on multi-index array slice".into(),
                            )
                        })?;
                        self.compile_expr(value)?;
                        self.compile_arrow_array_base_expr(expr)?;
                        for ix in indices {
                            self.compile_array_slice_index_expr(ix)?;
                        }
                        self.emit_op(
                            Op::ArrowArraySliceCompound(op_byte, indices.len() as u16),
                            line,
                            Some(root),
                        );
                        return Ok(());
                    }
                    match op {
                        BinOp::DefinedOr | BinOp::LogOr | BinOp::LogAnd => {
                            // Same last-slot short-circuit semantics as `@$r[i,j] //=` but with one
                            // subscript slot (`..` / list / `qw` flatten to multiple indices).
                            self.compile_arrow_array_base_expr(expr)?;
                            self.compile_array_slice_index_expr(index)?;
                            self.emit_op(Op::ArrowArraySlicePeekLast(1), line, Some(root));
                            let j = match *op {
                                BinOp::DefinedOr => {
                                    self.emit_op(Op::JumpIfDefinedKeep(0), line, Some(root))
                                }
                                BinOp::LogOr => {
                                    self.emit_op(Op::JumpIfTrueKeep(0), line, Some(root))
                                }
                                BinOp::LogAnd => {
                                    self.emit_op(Op::JumpIfFalseKeep(0), line, Some(root))
                                }
                                _ => unreachable!(),
                            };
                            self.compile_expr(value)?;
                            self.emit_op(Op::ArrowArraySliceRollValUnderSpecs(1), line, Some(root));
                            self.emit_op(Op::SetArrowArraySliceLastKeep(1), line, Some(root));
                            let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                            self.chunk.patch_jump_here(j);
                            self.emit_op(Op::ArrowArraySliceDropKeysKeepCur(1), line, Some(root));
                            self.chunk.patch_jump_here(j_end);
                        }
                        _ => {
                            let op_byte = scalar_compound_op_to_byte(*op).ok_or_else(|| {
                                CompileError::Unsupported("CompoundAssign op".into())
                            })?;
                            self.compile_expr(value)?;
                            self.compile_arrow_array_base_expr(expr)?;
                            self.compile_array_slice_index_expr(index)?;
                            self.emit_op(Op::ArrowArraySliceCompound(op_byte, 1), line, Some(root));
                        }
                    }
                } else if let ExprKind::HashSliceDeref { container, keys } = &target.kind {
                    // Single-key `@$href{"k"} OP= EXPR` matches `$href->{"k"} OP= EXPR` (ArrowHash).
                    // Multi-key `@$href{k1,k2} OP= EXPR` — Perl applies the op only to the last key.
                    if keys.is_empty() {
                        // Mirror `@h{} OP= EXPR`: evaluate invocant and RHS, then error (matches
                        // [`ExprKind::HashSlice`] empty `keys` compound path).
                        self.compile_expr(container)?;
                        self.emit_op(Op::Pop, line, Some(root));
                        self.compile_expr(value)?;
                        self.emit_op(Op::Pop, line, Some(root));
                        let idx = self
                            .chunk
                            .add_constant(PerlValue::string("assign to empty hash slice".into()));
                        self.emit_op(Op::RuntimeErrorConst(idx), line, Some(root));
                        self.emit_op(Op::LoadUndef, line, Some(root));
                        return Ok(());
                    }
                    if hash_slice_needs_slice_ops(keys) {
                        if matches!(op, BinOp::DefinedOr | BinOp::LogOr | BinOp::LogAnd) {
                            let k = keys.len() as u16;
                            self.compile_expr(container)?;
                            for hk in keys {
                                self.compile_expr(hk)?;
                            }
                            self.emit_op(Op::HashSliceDerefPeekLast(k), line, Some(root));
                            let j = match *op {
                                BinOp::DefinedOr => {
                                    self.emit_op(Op::JumpIfDefinedKeep(0), line, Some(root))
                                }
                                BinOp::LogOr => {
                                    self.emit_op(Op::JumpIfTrueKeep(0), line, Some(root))
                                }
                                BinOp::LogAnd => {
                                    self.emit_op(Op::JumpIfFalseKeep(0), line, Some(root))
                                }
                                _ => unreachable!(),
                            };
                            self.compile_expr(value)?;
                            self.emit_op(Op::HashSliceDerefRollValUnderKeys(k), line, Some(root));
                            self.emit_op(Op::HashSliceDerefSetLastKeep(k), line, Some(root));
                            let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                            self.chunk.patch_jump_here(j);
                            self.emit_op(Op::HashSliceDerefDropKeysKeepCur(k), line, Some(root));
                            self.chunk.patch_jump_here(j_end);
                            return Ok(());
                        }
                        let op_byte = scalar_compound_op_to_byte(*op).ok_or_else(|| {
                            CompileError::Unsupported(
                                "CompoundAssign op on multi-key hash slice".into(),
                            )
                        })?;
                        self.compile_expr(value)?;
                        self.compile_expr(container)?;
                        for hk in keys {
                            self.compile_expr(hk)?;
                        }
                        self.emit_op(
                            Op::HashSliceDerefCompound(op_byte, keys.len() as u16),
                            line,
                            Some(root),
                        );
                        return Ok(());
                    }
                    let hk = &keys[0];
                    match op {
                        BinOp::DefinedOr | BinOp::LogOr | BinOp::LogAnd => {
                            self.compile_expr(container)?;
                            self.compile_expr(hk)?;
                            self.emit_op(Op::Dup2, line, Some(root));
                            self.emit_op(Op::ArrowHash, line, Some(root));
                            let j = match *op {
                                BinOp::DefinedOr => {
                                    self.emit_op(Op::JumpIfDefinedKeep(0), line, Some(root))
                                }
                                BinOp::LogOr => {
                                    self.emit_op(Op::JumpIfTrueKeep(0), line, Some(root))
                                }
                                BinOp::LogAnd => {
                                    self.emit_op(Op::JumpIfFalseKeep(0), line, Some(root))
                                }
                                _ => unreachable!(),
                            };
                            self.compile_expr(value)?;
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::Rot, line, Some(root));
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::SetArrowHashKeep, line, Some(root));
                            let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                            self.chunk.patch_jump_here(j);
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::Pop, line, Some(root));
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::Pop, line, Some(root));
                            self.chunk.patch_jump_here(j_end);
                        }
                        _ => {
                            let vm_op = binop_to_vm_op(*op).ok_or_else(|| {
                                CompileError::Unsupported("CompoundAssign op".into())
                            })?;
                            self.compile_expr(container)?;
                            self.compile_expr(hk)?;
                            self.emit_op(Op::Dup2, line, Some(root));
                            self.emit_op(Op::ArrowHash, line, Some(root));
                            self.compile_expr(value)?;
                            self.emit_op(vm_op, line, Some(root));
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::Rot, line, Some(root));
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::SetArrowHash, line, Some(root));
                        }
                    }
                } else if let ExprKind::HashSlice { hash, keys } = &target.kind {
                    if keys.is_empty() {
                        if self.is_mysync_hash(hash) {
                            return Err(CompileError::Unsupported(
                                "mysync hash slice update".into(),
                            ));
                        }
                        self.check_strict_hash_access(hash, line)?;
                        self.check_hash_mutable(hash, line)?;
                        self.compile_expr(value)?;
                        self.emit_op(Op::Pop, line, Some(root));
                        let idx = self
                            .chunk
                            .add_constant(PerlValue::string("assign to empty hash slice".into()));
                        self.emit_op(Op::RuntimeErrorConst(idx), line, Some(root));
                        self.emit_op(Op::LoadUndef, line, Some(root));
                        return Ok(());
                    }
                    if self.is_mysync_hash(hash) {
                        return Err(CompileError::Unsupported("mysync hash slice update".into()));
                    }
                    self.check_strict_hash_access(hash, line)?;
                    self.check_hash_mutable(hash, line)?;
                    let hash_idx = self.chunk.intern_name(hash);
                    if hash_slice_needs_slice_ops(keys) {
                        if matches!(op, BinOp::DefinedOr | BinOp::LogOr | BinOp::LogAnd) {
                            let k = keys.len() as u16;
                            for hk in keys {
                                self.compile_expr(hk)?;
                            }
                            self.emit_op(Op::NamedHashSlicePeekLast(hash_idx, k), line, Some(root));
                            let j = match *op {
                                BinOp::DefinedOr => {
                                    self.emit_op(Op::JumpIfDefinedKeep(0), line, Some(root))
                                }
                                BinOp::LogOr => {
                                    self.emit_op(Op::JumpIfTrueKeep(0), line, Some(root))
                                }
                                BinOp::LogAnd => {
                                    self.emit_op(Op::JumpIfFalseKeep(0), line, Some(root))
                                }
                                _ => unreachable!(),
                            };
                            self.compile_expr(value)?;
                            self.emit_op(Op::NamedArraySliceRollValUnderSpecs(k), line, Some(root));
                            self.emit_op(
                                Op::SetNamedHashSliceLastKeep(hash_idx, k),
                                line,
                                Some(root),
                            );
                            let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                            self.chunk.patch_jump_here(j);
                            self.emit_op(Op::NamedHashSliceDropKeysKeepCur(k), line, Some(root));
                            self.chunk.patch_jump_here(j_end);
                            return Ok(());
                        }
                        let op_byte = scalar_compound_op_to_byte(*op).ok_or_else(|| {
                            CompileError::Unsupported(
                                "CompoundAssign op on multi-key hash slice".into(),
                            )
                        })?;
                        self.compile_expr(value)?;
                        for hk in keys {
                            self.compile_expr(hk)?;
                        }
                        self.emit_op(
                            Op::NamedHashSliceCompound(op_byte, hash_idx, keys.len() as u16),
                            line,
                            Some(root),
                        );
                        return Ok(());
                    }
                    let hk = &keys[0];
                    match op {
                        BinOp::DefinedOr | BinOp::LogOr | BinOp::LogAnd => {
                            self.compile_expr(hk)?;
                            self.emit_op(Op::Dup, line, Some(root));
                            self.emit_op(Op::GetHashElem(hash_idx), line, Some(root));
                            let j = match *op {
                                BinOp::DefinedOr => {
                                    self.emit_op(Op::JumpIfDefinedKeep(0), line, Some(root))
                                }
                                BinOp::LogOr => {
                                    self.emit_op(Op::JumpIfTrueKeep(0), line, Some(root))
                                }
                                BinOp::LogAnd => {
                                    self.emit_op(Op::JumpIfFalseKeep(0), line, Some(root))
                                }
                                _ => unreachable!(),
                            };
                            self.compile_expr(value)?;
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::SetHashElemKeep(hash_idx), line, Some(root));
                            let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                            self.chunk.patch_jump_here(j);
                            self.emit_op(Op::Swap, line, Some(root));
                            self.emit_op(Op::Pop, line, Some(root));
                            self.chunk.patch_jump_here(j_end);
                        }
                        _ => {
                            let op_byte = scalar_compound_op_to_byte(*op).ok_or_else(|| {
                                CompileError::Unsupported("CompoundAssign op".into())
                            })?;
                            self.compile_expr(value)?;
                            self.compile_expr(hk)?;
                            self.emit_op(
                                Op::NamedHashSliceCompound(op_byte, hash_idx, 1),
                                line,
                                Some(root),
                            );
                        }
                    }
                } else if let ExprKind::ArraySlice { array, indices } = &target.kind {
                    if indices.is_empty() {
                        if self.is_mysync_array(array) {
                            return Err(CompileError::Unsupported(
                                "mysync array slice update".into(),
                            ));
                        }
                        let q = self.qualify_stash_array_name(array);
                        self.check_array_mutable(&q, line)?;
                        let arr_idx = self.chunk.intern_name(&q);
                        if matches!(op, BinOp::DefinedOr | BinOp::LogOr | BinOp::LogAnd) {
                            self.compile_expr(value)?;
                            self.emit_op(Op::Pop, line, Some(root));
                            let idx = self.chunk.add_constant(PerlValue::string(
                                "assign to empty array slice".into(),
                            ));
                            self.emit_op(Op::RuntimeErrorConst(idx), line, Some(root));
                            self.emit_op(Op::LoadUndef, line, Some(root));
                            return Ok(());
                        }
                        let op_byte = scalar_compound_op_to_byte(*op).ok_or_else(|| {
                            CompileError::Unsupported(
                                "CompoundAssign op on named array slice".into(),
                            )
                        })?;
                        self.compile_expr(value)?;
                        self.emit_op(
                            Op::NamedArraySliceCompound(op_byte, arr_idx, 0),
                            line,
                            Some(root),
                        );
                        return Ok(());
                    }
                    if self.is_mysync_array(array) {
                        return Err(CompileError::Unsupported(
                            "mysync array slice update".into(),
                        ));
                    }
                    let q = self.qualify_stash_array_name(array);
                    self.check_array_mutable(&q, line)?;
                    let arr_idx = self.chunk.intern_name(&q);
                    if matches!(op, BinOp::DefinedOr | BinOp::LogOr | BinOp::LogAnd) {
                        let k = indices.len() as u16;
                        for ix in indices {
                            self.compile_array_slice_index_expr(ix)?;
                        }
                        self.emit_op(Op::NamedArraySlicePeekLast(arr_idx, k), line, Some(root));
                        let j = match *op {
                            BinOp::DefinedOr => {
                                self.emit_op(Op::JumpIfDefinedKeep(0), line, Some(root))
                            }
                            BinOp::LogOr => self.emit_op(Op::JumpIfTrueKeep(0), line, Some(root)),
                            BinOp::LogAnd => self.emit_op(Op::JumpIfFalseKeep(0), line, Some(root)),
                            _ => unreachable!(),
                        };
                        self.compile_expr(value)?;
                        self.emit_op(Op::NamedArraySliceRollValUnderSpecs(k), line, Some(root));
                        self.emit_op(Op::SetNamedArraySliceLastKeep(arr_idx, k), line, Some(root));
                        let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                        self.chunk.patch_jump_here(j);
                        self.emit_op(Op::NamedArraySliceDropKeysKeepCur(k), line, Some(root));
                        self.chunk.patch_jump_here(j_end);
                        return Ok(());
                    }
                    let op_byte = scalar_compound_op_to_byte(*op).ok_or_else(|| {
                        CompileError::Unsupported("CompoundAssign op on named array slice".into())
                    })?;
                    self.compile_expr(value)?;
                    for ix in indices {
                        self.compile_array_slice_index_expr(ix)?;
                    }
                    self.emit_op(
                        Op::NamedArraySliceCompound(op_byte, arr_idx, indices.len() as u16),
                        line,
                        Some(root),
                    );
                    return Ok(());
                } else if let ExprKind::AnonymousListSlice { source, indices } = &target.kind {
                    let ExprKind::Deref {
                        expr: inner,
                        kind: Sigil::Array,
                    } = &source.kind
                    else {
                        return Err(CompileError::Unsupported(
                            "CompoundAssign on AnonymousListSlice (non-array deref)".into(),
                        ));
                    };
                    if indices.is_empty() {
                        self.compile_arrow_array_base_expr(inner)?;
                        self.emit_op(Op::Pop, line, Some(root));
                        self.compile_expr(value)?;
                        self.emit_op(Op::Pop, line, Some(root));
                        let idx = self
                            .chunk
                            .add_constant(PerlValue::string("assign to empty array slice".into()));
                        self.emit_op(Op::RuntimeErrorConst(idx), line, Some(root));
                        self.emit_op(Op::LoadUndef, line, Some(root));
                        return Ok(());
                    }
                    if indices.len() > 1 {
                        if matches!(op, BinOp::DefinedOr | BinOp::LogOr | BinOp::LogAnd) {
                            let k = indices.len() as u16;
                            self.compile_arrow_array_base_expr(inner)?;
                            for ix in indices {
                                self.compile_array_slice_index_expr(ix)?;
                            }
                            self.emit_op(Op::ArrowArraySlicePeekLast(k), line, Some(root));
                            let j = match *op {
                                BinOp::DefinedOr => {
                                    self.emit_op(Op::JumpIfDefinedKeep(0), line, Some(root))
                                }
                                BinOp::LogOr => {
                                    self.emit_op(Op::JumpIfTrueKeep(0), line, Some(root))
                                }
                                BinOp::LogAnd => {
                                    self.emit_op(Op::JumpIfFalseKeep(0), line, Some(root))
                                }
                                _ => unreachable!(),
                            };
                            self.compile_expr(value)?;
                            self.emit_op(Op::ArrowArraySliceRollValUnderSpecs(k), line, Some(root));
                            self.emit_op(Op::SetArrowArraySliceLastKeep(k), line, Some(root));
                            let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                            self.chunk.patch_jump_here(j);
                            self.emit_op(Op::ArrowArraySliceDropKeysKeepCur(k), line, Some(root));
                            self.chunk.patch_jump_here(j_end);
                            return Ok(());
                        }
                        let op_byte = scalar_compound_op_to_byte(*op).ok_or_else(|| {
                            CompileError::Unsupported(
                                "CompoundAssign op on multi-index array slice".into(),
                            )
                        })?;
                        self.compile_expr(value)?;
                        self.compile_arrow_array_base_expr(inner)?;
                        for ix in indices {
                            self.compile_array_slice_index_expr(ix)?;
                        }
                        self.emit_op(
                            Op::ArrowArraySliceCompound(op_byte, indices.len() as u16),
                            line,
                            Some(root),
                        );
                        return Ok(());
                    }
                    let ix0 = &indices[0];
                    match op {
                        BinOp::DefinedOr | BinOp::LogOr | BinOp::LogAnd => {
                            self.compile_arrow_array_base_expr(inner)?;
                            self.compile_array_slice_index_expr(ix0)?;
                            self.emit_op(Op::ArrowArraySlicePeekLast(1), line, Some(root));
                            let j = match *op {
                                BinOp::DefinedOr => {
                                    self.emit_op(Op::JumpIfDefinedKeep(0), line, Some(root))
                                }
                                BinOp::LogOr => {
                                    self.emit_op(Op::JumpIfTrueKeep(0), line, Some(root))
                                }
                                BinOp::LogAnd => {
                                    self.emit_op(Op::JumpIfFalseKeep(0), line, Some(root))
                                }
                                _ => unreachable!(),
                            };
                            self.compile_expr(value)?;
                            self.emit_op(Op::ArrowArraySliceRollValUnderSpecs(1), line, Some(root));
                            self.emit_op(Op::SetArrowArraySliceLastKeep(1), line, Some(root));
                            let j_end = self.emit_op(Op::Jump(0), line, Some(root));
                            self.chunk.patch_jump_here(j);
                            self.emit_op(Op::ArrowArraySliceDropKeysKeepCur(1), line, Some(root));
                            self.chunk.patch_jump_here(j_end);
                        }
                        _ => {
                            let op_byte = scalar_compound_op_to_byte(*op).ok_or_else(|| {
                                CompileError::Unsupported("CompoundAssign op".into())
                            })?;
                            self.compile_expr(value)?;
                            self.compile_arrow_array_base_expr(inner)?;
                            self.compile_array_slice_index_expr(ix0)?;
                            self.emit_op(Op::ArrowArraySliceCompound(op_byte, 1), line, Some(root));
                        }
                    }
                } else {
                    return Err(CompileError::Unsupported(
                        "CompoundAssign on non-scalar".into(),
                    ));
                }
            }

            ExprKind::Ternary {
                condition,
                then_expr,
                else_expr,
            } => {
                self.compile_boolean_rvalue_condition(condition)?;
                let jump_else = self.emit_op(Op::JumpIfFalse(0), line, Some(root));
                self.compile_expr_ctx(then_expr, ctx)?;
                let jump_end = self.emit_op(Op::Jump(0), line, Some(root));
                self.chunk.patch_jump_here(jump_else);
                self.compile_expr_ctx(else_expr, ctx)?;
                self.chunk.patch_jump_here(jump_end);
            }

            ExprKind::Range {
                from,
                to,
                exclusive,
                step,
            } => {
                if ctx == WantarrayCtx::List {
                    self.compile_expr_ctx(from, WantarrayCtx::Scalar)?;
                    self.compile_expr_ctx(to, WantarrayCtx::Scalar)?;
                    if let Some(s) = step {
                        self.compile_expr_ctx(s, WantarrayCtx::Scalar)?;
                        self.emit_op(Op::RangeStep, line, Some(root));
                    } else {
                        self.emit_op(Op::Range, line, Some(root));
                    }
                } else if let (ExprKind::Regex(lp, lf), ExprKind::Regex(rp, rf)) =
                    (&from.kind, &to.kind)
                {
                    let slot = self.chunk.alloc_flip_flop_slot();
                    let lp_idx = self.chunk.add_constant(PerlValue::string(lp.clone()));
                    let lf_idx = self.chunk.add_constant(PerlValue::string(lf.clone()));
                    let rp_idx = self.chunk.add_constant(PerlValue::string(rp.clone()));
                    let rf_idx = self.chunk.add_constant(PerlValue::string(rf.clone()));
                    self.emit_op(
                        Op::RegexFlipFlop(
                            slot,
                            u8::from(*exclusive),
                            lp_idx,
                            lf_idx,
                            rp_idx,
                            rf_idx,
                        ),
                        line,
                        Some(root),
                    );
                } else if let (ExprKind::Regex(lp, lf), ExprKind::Eof(None)) =
                    (&from.kind, &to.kind)
                {
                    let slot = self.chunk.alloc_flip_flop_slot();
                    let lp_idx = self.chunk.add_constant(PerlValue::string(lp.clone()));
                    let lf_idx = self.chunk.add_constant(PerlValue::string(lf.clone()));
                    self.emit_op(
                        Op::RegexEofFlipFlop(slot, u8::from(*exclusive), lp_idx, lf_idx),
                        line,
                        Some(root),
                    );
                } else if matches!(
                    (&from.kind, &to.kind),
                    (ExprKind::Regex(_, _), ExprKind::Eof(Some(_)))
                ) {
                    return Err(CompileError::Unsupported(
                        "regex flip-flop with eof(HANDLE) is not supported".into(),
                    ));
                } else if let ExprKind::Regex(lp, lf) = &from.kind {
                    let slot = self.chunk.alloc_flip_flop_slot();
                    let lp_idx = self.chunk.add_constant(PerlValue::string(lp.clone()));
                    let lf_idx = self.chunk.add_constant(PerlValue::string(lf.clone()));
                    if matches!(to.kind, ExprKind::Integer(_) | ExprKind::Float(_)) {
                        let line_target = match &to.kind {
                            ExprKind::Integer(n) => *n,
                            ExprKind::Float(f) => *f as i64,
                            _ => unreachable!(),
                        };
                        let line_cidx = self.chunk.add_constant(PerlValue::integer(line_target));
                        self.emit_op(
                            Op::RegexFlipFlopDotLineRhs(
                                slot,
                                u8::from(*exclusive),
                                lp_idx,
                                lf_idx,
                                line_cidx,
                            ),
                            line,
                            Some(root),
                        );
                    } else {
                        let rhs_idx = self
                            .chunk
                            .add_regex_flip_flop_rhs_expr_entry((**to).clone());
                        self.emit_op(
                            Op::RegexFlipFlopExprRhs(
                                slot,
                                u8::from(*exclusive),
                                lp_idx,
                                lf_idx,
                                rhs_idx,
                            ),
                            line,
                            Some(root),
                        );
                    }
                } else {
                    self.compile_expr(from)?;
                    self.compile_expr(to)?;
                    let slot = self.chunk.alloc_flip_flop_slot();
                    self.emit_op(
                        Op::ScalarFlipFlop(slot, u8::from(*exclusive)),
                        line,
                        Some(root),
                    );
                }
            }

            ExprKind::SliceRange { .. } => {
                // Open-ended slice ranges (`:N`, `N:`, `::-1`, `::`) only have meaning
                // inside slice subscripts (`@arr[...]`, `@h{...}`), where they are
                // intercepted by the slice arms above. Anywhere else is a hard error —
                // we have no container length context to resolve open ends.
                return Err(CompileError::Unsupported(
                    "open-ended slice range (`:N`/`N:`/`::-1`) is only valid inside `@arr[...]` or `@h{...}` subscripts"
                        .into(),
                ));
            }

            ExprKind::Repeat {
                expr,
                count,
                list_repeat,
            } => {
                if *list_repeat {
                    // List context for the LHS so `(EXPR)` and `qw(...)` flatten
                    // into the array we'll replicate.
                    self.compile_expr_ctx(expr, WantarrayCtx::List)?;
                    self.compile_expr(count)?;
                    self.emit_op(Op::ListRepeat, line, Some(root));
                } else {
                    self.compile_expr(expr)?;
                    self.compile_expr(count)?;
                    self.emit_op(Op::StringRepeat, line, Some(root));
                }
            }

            // ── Function calls ──
            ExprKind::FuncCall { name, args } => {
                // Stryke builtins are unprefixed; `CORE::name` callers route back to the
                // bare-name fast path so the arms below stay flat.
                let dispatch_name: &str = name.strip_prefix("CORE::").unwrap_or(name.as_str());
                match dispatch_name {
                    // read(FH, $buf, LEN) — emit ReadIntoVar with the buffer variable's name index
                    "read" => {
                        if args.len() < 3 {
                            return Err(CompileError::Unsupported(
                                "read() needs at least 3 args".into(),
                            ));
                        }
                        // Extract buffer variable name from 2nd arg
                        let buf_name =
                            match &args[1].kind {
                                ExprKind::ScalarVar(n) => n.clone(),
                                _ => return Err(CompileError::Unsupported(
                                    "read() buffer must be a simple scalar variable for bytecode"
                                        .into(),
                                )),
                            };
                        let buf_idx = self.chunk.intern_name(&buf_name);
                        // Stack: [filehandle, length]
                        self.compile_expr(&args[0])?; // filehandle
                        self.compile_expr(&args[2])?; // length
                        self.emit_op(Op::ReadIntoVar(buf_idx), line, Some(root));
                    }
                    // `defer { BLOCK }` — desugared by parser to `defer__internal(fn { BLOCK })`
                    "defer__internal" => {
                        if args.len() != 1 {
                            return Err(CompileError::Unsupported(
                                "defer__internal expects exactly one argument".into(),
                            ));
                        }
                        // Compile the coderef argument; afterwards, un-mark
                        // the defer block as a sub-body so the closure-write
                        // check (DESIGN-001) doesn't flag mutations of outer
                        // `my` vars from inside `defer { ... }`. defer runs
                        // synchronously at scope exit and is intentionally
                        // shared-state with the enclosing scope.
                        self.compile_expr(&args[0])?;
                        if let ExprKind::CodeRef { .. } = &args[0].kind {
                            // The most-recently-pushed CodeRef block index is
                            // the highest one in `sub_body_block_indices`.
                            if let Some(max_idx) = self.sub_body_block_indices.iter().copied().max()
                            {
                                self.sub_body_block_indices.remove(&max_idx);
                            }
                        }
                        self.emit_op(Op::DeferBlock, line, Some(root));
                    }
                    "deque" => {
                        if !args.is_empty() {
                            return Err(CompileError::Unsupported(
                                "deque() takes no arguments".into(),
                            ));
                        }
                        self.emit_op(
                            Op::CallBuiltin(BuiltinId::DequeNew as u16, 0),
                            line,
                            Some(root),
                        );
                    }
                    "inc" => {
                        let arg = args.first().cloned().unwrap_or_else(|| Expr {
                            kind: ExprKind::ScalarVar("_".into()),
                            line,
                        });
                        self.compile_expr(&arg)?;
                        self.emit_op(Op::Inc, line, Some(root));
                    }
                    "dec" => {
                        let arg = args.first().cloned().unwrap_or_else(|| Expr {
                            kind: ExprKind::ScalarVar("_".into()),
                            line,
                        });
                        self.compile_expr(&arg)?;
                        self.emit_op(Op::Dec, line, Some(root));
                    }
                    "heap" => {
                        if args.len() != 1 {
                            return Err(CompileError::Unsupported(
                                "heap() expects one comparator sub".into(),
                            ));
                        }
                        self.compile_expr(&args[0])?;
                        self.emit_op(
                            Op::CallBuiltin(BuiltinId::HeapNew as u16, 1),
                            line,
                            Some(root),
                        );
                    }
                    "pipeline" => {
                        for arg in args {
                            self.compile_expr_ctx(arg, WantarrayCtx::List)?;
                        }
                        self.emit_op(
                            Op::CallBuiltin(BuiltinId::Pipeline as u16, args.len() as u8),
                            line,
                            Some(root),
                        );
                    }
                    "par_pipeline" => {
                        for arg in args {
                            self.compile_expr_ctx(arg, WantarrayCtx::List)?;
                        }
                        self.emit_op(
                            Op::CallBuiltin(BuiltinId::ParPipeline as u16, args.len() as u8),
                            line,
                            Some(root),
                        );
                    }
                    "par_pipeline_stream" => {
                        for arg in args {
                            self.compile_expr_ctx(arg, WantarrayCtx::List)?;
                        }
                        self.emit_op(
                            Op::CallBuiltin(BuiltinId::ParPipelineStream as u16, args.len() as u8),
                            line,
                            Some(root),
                        );
                    }
                    // `collect(EXPR)` — compile the argument in list context so nested
                    // `map { }` / `grep { }` keep a pipeline handle (scalar context adds
                    // `StackArrayLen`, which turns a pipeline into `1`). At runtime, a
                    // pipeline runs staged ops; any other value is materialized as an array
                    // (`|> … |> collect()`).
                    "collect" => {
                        for arg in args {
                            self.compile_expr_ctx(arg, WantarrayCtx::List)?;
                        }
                        let name_idx = self.chunk.intern_name(&self.qualify_sub_key(name));
                        self.emit_op(
                            Op::Call(name_idx, args.len() as u8, ctx.as_byte()),
                            line,
                            Some(root),
                        );
                    }
                    "ppool" => {
                        if args.len() != 1 {
                            return Err(CompileError::Unsupported(
                                "ppool() expects one argument (worker count)".into(),
                            ));
                        }
                        self.compile_expr(&args[0])?;
                        self.emit_op(
                            Op::CallBuiltin(BuiltinId::Ppool as u16, 1),
                            line,
                            Some(root),
                        );
                    }
                    "barrier" => {
                        if args.len() != 1 {
                            return Err(CompileError::Unsupported(
                                "barrier() expects one argument (party count)".into(),
                            ));
                        }
                        self.compile_expr(&args[0])?;
                        self.emit_op(
                            Op::CallBuiltin(BuiltinId::BarrierNew as u16, 1),
                            line,
                            Some(root),
                        );
                    }
                    "pselect" => {
                        if args.is_empty() {
                            return Err(CompileError::Unsupported(
                                "pselect() expects at least one pchannel receiver".into(),
                            ));
                        }
                        for arg in args {
                            self.compile_expr(arg)?;
                        }
                        self.emit_op(
                            Op::CallBuiltin(BuiltinId::Pselect as u16, args.len() as u8),
                            line,
                            Some(root),
                        );
                    }
                    "ssh" => {
                        for arg in args {
                            self.compile_expr(arg)?;
                        }
                        self.emit_op(
                            Op::CallBuiltin(BuiltinId::Ssh as u16, args.len() as u8),
                            line,
                            Some(root),
                        );
                    }
                    "rmdir" => {
                        for arg in args {
                            self.compile_expr(arg)?;
                        }
                        self.emit_op(
                            Op::CallBuiltin(BuiltinId::Rmdir as u16, args.len() as u8),
                            line,
                            Some(root),
                        );
                    }
                    "utime" => {
                        for arg in args {
                            self.compile_expr(arg)?;
                        }
                        self.emit_op(
                            Op::CallBuiltin(BuiltinId::Utime as u16, args.len() as u8),
                            line,
                            Some(root),
                        );
                    }
                    "umask" => {
                        for arg in args {
                            self.compile_expr(arg)?;
                        }
                        self.emit_op(
                            Op::CallBuiltin(BuiltinId::Umask as u16, args.len() as u8),
                            line,
                            Some(root),
                        );
                    }
                    "getcwd" => {
                        for arg in args {
                            self.compile_expr(arg)?;
                        }
                        self.emit_op(
                            Op::CallBuiltin(BuiltinId::Getcwd as u16, args.len() as u8),
                            line,
                            Some(root),
                        );
                    }
                    "pipe" => {
                        if args.len() != 2 {
                            return Err(CompileError::Unsupported(
                                "pipe requires exactly two arguments".into(),
                            ));
                        }
                        for arg in args {
                            self.compile_expr(arg)?;
                        }
                        self.emit_op(Op::CallBuiltin(BuiltinId::Pipe as u16, 2), line, Some(root));
                    }
                    "uniq" | "distinct" | "flatten" | "set" | "with_index" | "list_count"
                    | "list_size" | "count" | "size" | "cnt" | "len" | "sum" | "sum0"
                    | "product" | "min" | "max" | "mean" | "median" | "mode" | "stddev"
                    | "variance" => {
                        // Fast path for `len @arr` / `cnt @arr` / `count @arr` and the deref
                        // variants `len @$ref` / `len @{$ref}`: emit the same direct length op
                        // (`ArrayLen` / `ArrayDerefLen`) that `scalar @arr` uses, so the
                        // idiomatic stryke spelling is no slower than the Perl-compat one.
                        if matches!(
                            name.as_str(),
                            "count" | "cnt" | "size" | "len" | "list_count" | "list_size"
                        ) && args.len() == 1
                        {
                            match &args[0].kind {
                                ExprKind::ArrayVar(arr_name) => {
                                    self.check_strict_array_access(arr_name, line)?;
                                    let idx = self
                                        .chunk
                                        .intern_name(&self.qualify_stash_array_name(arr_name));
                                    self.emit_op(Op::ArrayLen(idx), line, Some(root));
                                    return Ok(());
                                }
                                ExprKind::Deref {
                                    expr,
                                    kind: Sigil::Array,
                                } => {
                                    self.compile_expr(expr)?;
                                    self.emit_op(Op::ArrayDerefLen, line, Some(root));
                                    return Ok(());
                                }
                                _ => {}
                            }
                        }
                        for arg in args {
                            self.compile_expr_ctx(arg, WantarrayCtx::List)?;
                        }
                        let name_idx = self.chunk.intern_name(&self.qualify_sub_key(name));
                        self.emit_op(
                            Op::Call(name_idx, args.len() as u8, ctx.as_byte()),
                            line,
                            Some(root),
                        );
                    }
                    "shuffle" => {
                        for arg in args {
                            self.compile_expr_ctx(arg, WantarrayCtx::List)?;
                        }
                        let name_idx = self.chunk.intern_name(&self.qualify_sub_key(name));
                        self.emit_op(
                            Op::Call(name_idx, args.len() as u8, ctx.as_byte()),
                            line,
                            Some(root),
                        );
                    }
                    "chunked" | "windowed" => {
                        match args.len() {
                            0 => {
                                return Err(CompileError::Unsupported(
                                "chunked/windowed need (LIST, N) or unary N (e.g. `|> chunked(2)`)"
                                    .into(),
                            ));
                            }
                            1 => {
                                // chunked @l / windowed @l — compile in list context, default size
                                self.compile_expr_ctx(&args[0], WantarrayCtx::List)?;
                            }
                            2 => {
                                self.compile_expr_ctx(&args[0], WantarrayCtx::List)?;
                                self.compile_expr(&args[1])?;
                            }
                            _ => {
                                return Err(CompileError::Unsupported(
                                "chunked/windowed expect exactly two arguments (LIST, N); use a single list expression for the first operand".into(),
                            ));
                            }
                        }
                        let name_idx = self.chunk.intern_name(&self.qualify_sub_key(name));
                        self.emit_op(
                            Op::Call(name_idx, args.len() as u8, ctx.as_byte()),
                            line,
                            Some(root),
                        );
                    }
                    "take" | "head" | "tail" | "drop" => {
                        if args.is_empty() {
                            return Err(CompileError::Unsupported(
                                "take/head/tail/drop expect LIST..., N or unary N".into(),
                            ));
                        }
                        if args.len() == 1 {
                            // head @l == head @l, 1 — evaluate in list context
                            self.compile_expr_ctx(&args[0], WantarrayCtx::List)?;
                        } else {
                            for a in &args[..args.len() - 1] {
                                self.compile_expr_ctx(a, WantarrayCtx::List)?;
                            }
                            self.compile_expr(&args[args.len() - 1])?;
                        }
                        let name_idx = self.chunk.intern_name(&self.qualify_sub_key(name));
                        self.emit_op(
                            Op::Call(name_idx, args.len() as u8, ctx.as_byte()),
                            line,
                            Some(root),
                        );
                    }
                    "any" | "all" | "none" | "first" | "take_while" | "drop_while" | "tap"
                    | "peek" => {
                        // Three shapes:
                        //   `any { BLOCK } @list`           — block form
                        //   `any(fn { ... }, 1, 2, 3)`      — slurpy `(&@)` form
                        //   `any($coderef, @list)`          — coderef-in-block-position
                        //   `any($f, @list)` (no parens)    — same, runtime dispatch
                        // Builtin runtime checks `as_code_ref()` and dispatches; if
                        // the first arg isn't a coderef the builtin uses its
                        // value-shape semantics. Compiler stays out of the way.
                        if args.is_empty() {
                            return Err(CompileError::Unsupported(
                            "any/all/none/first/take_while/drop_while/tap/peek expect BLOCK, LIST"
                                .into(),
                        ));
                        }
                        self.compile_expr(&args[0])?;
                        for arg in &args[1..] {
                            self.compile_expr_ctx(arg, WantarrayCtx::List)?;
                        }
                        let name_idx = self.chunk.intern_name(&self.qualify_sub_key(name));
                        self.emit_op(
                            Op::Call(name_idx, args.len() as u8, ctx.as_byte()),
                            line,
                            Some(root),
                        );
                    }
                    "group_by" | "chunk_by" => {
                        if args.len() != 2 {
                            return Err(CompileError::Unsupported(
                                "group_by/chunk_by expect { BLOCK } or EXPR, LIST".into(),
                            ));
                        }
                        self.compile_expr_ctx(&args[1], WantarrayCtx::List)?;
                        match &args[0].kind {
                            ExprKind::CodeRef { body, .. } => {
                                let block_idx = self.add_deferred_block(body.clone());
                                self.emit_op(Op::ChunkByWithBlock(block_idx), line, Some(root));
                            }
                            _ => {
                                let idx = self.chunk.add_map_expr_entry(args[0].clone());
                                self.emit_op(Op::ChunkByWithExpr(idx), line, Some(root));
                            }
                        }
                        if ctx != WantarrayCtx::List {
                            self.emit_op(Op::StackArrayLen, line, Some(root));
                        }
                    }
                    "zip" | "zip_longest" => {
                        for arg in args {
                            self.compile_expr_ctx(arg, WantarrayCtx::List)?;
                        }
                        // Both forms are stryke bare-name builtins; the VM slow path strips the
                        // `main::` qualifier and routes through `try_builtin` → `dispatch_by_name`.
                        let name_idx = self.chunk.intern_name(&self.qualify_sub_key(dispatch_name));
                        self.emit_op(
                            Op::Call(name_idx, args.len() as u8, ctx.as_byte()),
                            line,
                            Some(root),
                        );
                    }
                    "puniq" => {
                        if args.is_empty() || args.len() > 2 {
                            return Err(CompileError::Unsupported(
                                "puniq expects LIST [, progress => EXPR]".into(),
                            ));
                        }
                        if args.len() == 2 {
                            self.compile_expr(&args[1])?;
                        } else {
                            self.emit_op(Op::LoadInt(0), line, Some(root));
                        }
                        self.compile_expr_ctx(&args[0], WantarrayCtx::List)?;
                        self.emit_op(Op::Puniq, line, Some(root));
                        if ctx != WantarrayCtx::List {
                            self.emit_op(Op::StackArrayLen, line, Some(root));
                        }
                    }
                    "pfirst" | "pany" => {
                        if args.len() < 2 || args.len() > 3 {
                            return Err(CompileError::Unsupported(
                                "pfirst/pany expect BLOCK, LIST [, progress => EXPR]".into(),
                            ));
                        }
                        let body = match &args[0].kind {
                            ExprKind::CodeRef { body, .. } => body,
                            _ => {
                                return Err(CompileError::Unsupported(
                                    "pfirst/pany: first argument must be a { BLOCK }".into(),
                                ));
                            }
                        };
                        if args.len() == 3 {
                            self.compile_expr(&args[2])?;
                        } else {
                            self.emit_op(Op::LoadInt(0), line, Some(root));
                        }
                        self.compile_expr_ctx(&args[1], WantarrayCtx::List)?;
                        let block_idx = self.add_deferred_block(body.clone());
                        let op = if name == "pfirst" {
                            Op::PFirstWithBlock(block_idx)
                        } else {
                            Op::PAnyWithBlock(block_idx)
                        };
                        self.emit_op(op, line, Some(root));
                    }
                    _ => {
                        // Generic sub call: args are in list context so `f(1..10)`, `f(@a)`,
                        // `f(reverse LIST)` etc. flatten into `@_`. [`Self::pop_call_operands_flattened`]
                        // splats any array value at runtime, matching Perl's `@_` semantics.
                        for arg in args {
                            self.compile_expr_ctx(arg, WantarrayCtx::List)?;
                        }
                        let q = self.qualify_sub_key(name);
                        let name_idx = self.chunk.intern_name(&q);
                        self.emit_op(
                            Op::Call(name_idx, args.len() as u8, ctx.as_byte()),
                            line,
                            Some(root),
                        );
                    }
                }
            }

            // ── Method calls ──
            ExprKind::MethodCall {
                object,
                method,
                args,
                super_call,
            } => {
                self.compile_expr(object)?;
                for arg in args {
                    self.compile_expr_ctx(arg, WantarrayCtx::List)?;
                }
                let name_idx = self.chunk.intern_name(method);
                if *super_call {
                    self.emit_op(
                        Op::MethodCallSuper(name_idx, args.len() as u8, ctx.as_byte()),
                        line,
                        Some(root),
                    );
                } else {
                    self.emit_op(
                        Op::MethodCall(name_idx, args.len() as u8, ctx.as_byte()),
                        line,
                        Some(root),
                    );
                }
            }
            ExprKind::IndirectCall {
                target,
                args,
                ampersand: _,
                pass_caller_arglist,
            } => {
                self.compile_expr(target)?;
                if !pass_caller_arglist {
                    for a in args {
                        self.compile_expr_ctx(a, WantarrayCtx::List)?;
                    }
                }
                let argc = if *pass_caller_arglist {
                    0
                } else {
                    args.len() as u8
                };
                self.emit_op(
                    Op::IndirectCall(
                        argc,
                        ctx.as_byte(),
                        if *pass_caller_arglist { 1 } else { 0 },
                    ),
                    line,
                    Some(root),
                );
            }

            // ── Print / Say / Printf ──
            ExprKind::Print { handle, args } => {
                for arg in args {
                    self.compile_expr_ctx(arg, WantarrayCtx::List)?;
                }
                let h = handle.as_ref().map(|s| self.chunk.intern_name(s));
                self.emit_op(Op::Print(h, args.len() as u8), line, Some(root));
            }
            ExprKind::Say { handle, args } => {
                for arg in args {
                    self.compile_expr_ctx(arg, WantarrayCtx::List)?;
                }
                let h = handle.as_ref().map(|s| self.chunk.intern_name(s));
                self.emit_op(Op::Say(h, args.len() as u8), line, Some(root));
            }
            ExprKind::Printf { args, .. } => {
                // printf's format + arg list is Perl list context — ranges, arrays, and
                // `reverse`/`sort`/`grep` flatten into format argument positions.
                for arg in args {
                    self.compile_expr_ctx(arg, WantarrayCtx::List)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Printf as u16, args.len() as u8),
                    line,
                    Some(root),
                );
            }

            // ── Die / Warn ──
            ExprKind::Die(args) => {
                // die / warn take a list that gets stringified and concatenated — list context
                // so `die 1..5` matches Perl's "12345" stringification.
                for arg in args {
                    self.compile_expr_ctx(arg, WantarrayCtx::List)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Die as u16, args.len() as u8),
                    line,
                    Some(root),
                );
            }
            ExprKind::Warn(args) => {
                for arg in args {
                    self.compile_expr_ctx(arg, WantarrayCtx::List)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Warn as u16, args.len() as u8),
                    line,
                    Some(root),
                );
            }
            ExprKind::Exit(code) => {
                if let Some(c) = code {
                    self.compile_expr(c)?;
                    self.emit_op(Op::CallBuiltin(BuiltinId::Exit as u16, 1), line, Some(root));
                } else {
                    self.emit_op(Op::LoadInt(0), line, Some(root));
                    self.emit_op(Op::CallBuiltin(BuiltinId::Exit as u16, 1), line, Some(root));
                }
            }

            // ── Array ops ──
            ExprKind::Push { array, values } => {
                if let ExprKind::ArrayVar(name) = &array.kind {
                    let idx = self.chunk.intern_name(&self.qualify_stash_array_name(name));
                    for v in values {
                        self.compile_expr_ctx(v, WantarrayCtx::List)?;
                        self.emit_op(Op::PushArray(idx), line, Some(root));
                    }
                    self.emit_op(Op::ArrayLen(idx), line, Some(root));
                } else if let ExprKind::Deref {
                    expr: aref_expr,
                    kind: Sigil::Array,
                } = &array.kind
                {
                    // Autovivifiable inner shapes (`$x`, `$h{k}`, `$a[i]`) need lvalue
                    // resolution: when the slot is undef, `push @{...}` must create a new
                    // arrayref and store it back. Routed through PushExpr where
                    // `try_eval_array_deref_container` handles autoviv.
                    let needs_autoviv = matches!(
                        &aref_expr.kind,
                        ExprKind::ScalarVar(_)
                            | ExprKind::HashElement { .. }
                            | ExprKind::ArrayElement { .. }
                    );
                    if needs_autoviv {
                        let pool = self
                            .chunk
                            .add_push_expr_entry(array.as_ref().clone(), values.clone());
                        self.emit_op(Op::PushExpr(pool), line, Some(root));
                    } else {
                        self.compile_expr(aref_expr)?;
                        for v in values {
                            self.emit_op(Op::Dup, line, Some(root));
                            self.compile_expr_ctx(v, WantarrayCtx::List)?;
                            self.emit_op(Op::PushArrayDeref, line, Some(root));
                        }
                        self.emit_op(Op::ArrayDerefLen, line, Some(root));
                    }
                } else {
                    let pool = self
                        .chunk
                        .add_push_expr_entry(array.as_ref().clone(), values.clone());
                    self.emit_op(Op::PushExpr(pool), line, Some(root));
                }
            }
            ExprKind::Pop(array) => {
                if let ExprKind::ArrayVar(name) = &array.kind {
                    let idx = self.chunk.intern_name(&self.qualify_stash_array_name(name));
                    self.emit_op(Op::PopArray(idx), line, Some(root));
                } else if let ExprKind::Deref {
                    expr: aref_expr,
                    kind: Sigil::Array,
                } = &array.kind
                {
                    let needs_autoviv = matches!(
                        &aref_expr.kind,
                        ExprKind::ScalarVar(_)
                            | ExprKind::HashElement { .. }
                            | ExprKind::ArrayElement { .. }
                    );
                    if needs_autoviv {
                        let pool = self.chunk.add_pop_expr_entry(array.as_ref().clone());
                        self.emit_op(Op::PopExpr(pool), line, Some(root));
                    } else {
                        self.compile_expr(aref_expr)?;
                        self.emit_op(Op::PopArrayDeref, line, Some(root));
                    }
                } else {
                    let pool = self.chunk.add_pop_expr_entry(array.as_ref().clone());
                    self.emit_op(Op::PopExpr(pool), line, Some(root));
                }
            }
            ExprKind::Shift(array) => {
                if let ExprKind::ArrayVar(name) = &array.kind {
                    let idx = self.chunk.intern_name(&self.qualify_stash_array_name(name));
                    self.emit_op(Op::ShiftArray(idx), line, Some(root));
                } else if let ExprKind::Deref {
                    expr: aref_expr,
                    kind: Sigil::Array,
                } = &array.kind
                {
                    let needs_autoviv = matches!(
                        &aref_expr.kind,
                        ExprKind::ScalarVar(_)
                            | ExprKind::HashElement { .. }
                            | ExprKind::ArrayElement { .. }
                    );
                    if needs_autoviv {
                        let pool = self.chunk.add_shift_expr_entry(array.as_ref().clone());
                        self.emit_op(Op::ShiftExpr(pool), line, Some(root));
                    } else {
                        self.compile_expr(aref_expr)?;
                        self.emit_op(Op::ShiftArrayDeref, line, Some(root));
                    }
                } else {
                    let pool = self.chunk.add_shift_expr_entry(array.as_ref().clone());
                    self.emit_op(Op::ShiftExpr(pool), line, Some(root));
                }
            }
            ExprKind::Unshift { array, values } => {
                if let ExprKind::ArrayVar(name) = &array.kind {
                    let q = self.qualify_stash_array_name(name);
                    let name_const = self.chunk.add_constant(PerlValue::string(q));
                    self.emit_op(Op::LoadConst(name_const), line, Some(root));
                    for v in values {
                        self.compile_expr_ctx(v, WantarrayCtx::List)?;
                    }
                    let nargs = (1 + values.len()) as u8;
                    self.emit_op(
                        Op::CallBuiltin(BuiltinId::Unshift as u16, nargs),
                        line,
                        Some(root),
                    );
                } else if let ExprKind::Deref {
                    expr: aref_expr,
                    kind: Sigil::Array,
                } = &array.kind
                {
                    let needs_autoviv = matches!(
                        &aref_expr.kind,
                        ExprKind::ScalarVar(_)
                            | ExprKind::HashElement { .. }
                            | ExprKind::ArrayElement { .. }
                    );
                    if needs_autoviv || values.len() > u8::MAX as usize {
                        let pool = self
                            .chunk
                            .add_unshift_expr_entry(array.as_ref().clone(), values.clone());
                        self.emit_op(Op::UnshiftExpr(pool), line, Some(root));
                    } else {
                        self.compile_expr(aref_expr)?;
                        for v in values {
                            self.compile_expr_ctx(v, WantarrayCtx::List)?;
                        }
                        self.emit_op(Op::UnshiftArrayDeref(values.len() as u8), line, Some(root));
                    }
                } else {
                    let pool = self
                        .chunk
                        .add_unshift_expr_entry(array.as_ref().clone(), values.clone());
                    self.emit_op(Op::UnshiftExpr(pool), line, Some(root));
                }
            }
            ExprKind::Splice {
                array,
                offset,
                length,
                replacement,
            } => {
                self.emit_op(Op::WantarrayPush(ctx.as_byte()), line, Some(root));
                if let ExprKind::ArrayVar(name) = &array.kind {
                    let q = self.qualify_stash_array_name(name);
                    let name_const = self.chunk.add_constant(PerlValue::string(q));
                    self.emit_op(Op::LoadConst(name_const), line, Some(root));
                    if let Some(o) = offset {
                        self.compile_expr(o)?;
                    } else {
                        self.emit_op(Op::LoadInt(0), line, Some(root));
                    }
                    if let Some(l) = length {
                        self.compile_expr(l)?;
                    } else {
                        self.emit_op(Op::LoadUndef, line, Some(root));
                    }
                    for r in replacement {
                        self.compile_expr(r)?;
                    }
                    let nargs = (3 + replacement.len()) as u8;
                    self.emit_op(
                        Op::CallBuiltin(BuiltinId::Splice as u16, nargs),
                        line,
                        Some(root),
                    );
                } else if let ExprKind::Deref {
                    expr: aref_expr,
                    kind: Sigil::Array,
                } = &array.kind
                {
                    if replacement.len() > u8::MAX as usize {
                        let pool = self.chunk.add_splice_expr_entry(
                            array.as_ref().clone(),
                            offset.as_deref().cloned(),
                            length.as_deref().cloned(),
                            replacement.clone(),
                        );
                        self.emit_op(Op::SpliceExpr(pool), line, Some(root));
                    } else {
                        self.compile_expr(aref_expr)?;
                        if let Some(o) = offset {
                            self.compile_expr(o)?;
                        } else {
                            self.emit_op(Op::LoadInt(0), line, Some(root));
                        }
                        if let Some(l) = length {
                            self.compile_expr(l)?;
                        } else {
                            self.emit_op(Op::LoadUndef, line, Some(root));
                        }
                        for r in replacement {
                            self.compile_expr(r)?;
                        }
                        self.emit_op(
                            Op::SpliceArrayDeref(replacement.len() as u8),
                            line,
                            Some(root),
                        );
                    }
                } else {
                    let pool = self.chunk.add_splice_expr_entry(
                        array.as_ref().clone(),
                        offset.as_deref().cloned(),
                        length.as_deref().cloned(),
                        replacement.clone(),
                    );
                    self.emit_op(Op::SpliceExpr(pool), line, Some(root));
                }
                self.emit_op(Op::WantarrayPop, line, Some(root));
            }
            ExprKind::ScalarContext(inner) => {
                // `scalar EXPR` forces scalar context on EXPR regardless of the outer context
                // (e.g. `print scalar grep { } @x` — grep's result is a count, not a list).
                self.compile_expr_ctx(inner, WantarrayCtx::Scalar)?;
                // Then apply aggregate scalar semantics (set size, pipeline source len, …) —
                // same as [`Op::ValueScalarContext`] / [`PerlValue::scalar_context`].
                self.emit_op(Op::ValueScalarContext, line, Some(root));
            }

            // ── Hash ops ──
            ExprKind::Delete(inner) => {
                if let ExprKind::HashElement { hash, key } = &inner.kind {
                    self.check_hash_mutable(hash, line)?;
                    let idx = self.chunk.intern_name(hash);
                    self.compile_expr(key)?;
                    self.emit_op(Op::DeleteHashElem(idx), line, Some(root));
                } else if let ExprKind::ArrayElement { array, index } = &inner.kind {
                    self.check_strict_array_access(array, line)?;
                    let q = self.qualify_stash_array_name(array);
                    self.check_array_mutable(&q, line)?;
                    let arr_idx = self.chunk.intern_name(&q);
                    self.compile_expr(index)?;
                    self.emit_op(Op::DeleteArrayElem(arr_idx), line, Some(root));
                } else if let ExprKind::ArrowDeref {
                    expr: container,
                    index,
                    kind: DerefKind::Hash,
                } = &inner.kind
                {
                    self.compile_arrow_hash_base_expr(container)?;
                    self.compile_expr(index)?;
                    self.emit_op(Op::DeleteArrowHashElem, line, Some(root));
                } else if let ExprKind::ArrowDeref {
                    expr: container,
                    index,
                    kind: DerefKind::Array,
                } = &inner.kind
                {
                    if arrow_deref_arrow_subscript_is_plain_scalar_index(index) {
                        self.compile_expr(container)?;
                        self.compile_expr(index)?;
                        self.emit_op(Op::DeleteArrowArrayElem, line, Some(root));
                    } else {
                        let pool = self.chunk.add_delete_expr_entry(inner.as_ref().clone());
                        self.emit_op(Op::DeleteExpr(pool), line, Some(root));
                    }
                } else {
                    let pool = self.chunk.add_delete_expr_entry(inner.as_ref().clone());
                    self.emit_op(Op::DeleteExpr(pool), line, Some(root));
                }
            }
            ExprKind::Exists(inner) => {
                if let ExprKind::HashElement { hash, key } = &inner.kind {
                    let idx = self.chunk.intern_name(hash);
                    self.compile_expr(key)?;
                    self.emit_op(Op::ExistsHashElem(idx), line, Some(root));
                } else if let ExprKind::ArrayElement { array, index } = &inner.kind {
                    self.check_strict_array_access(array, line)?;
                    let arr_idx = self
                        .chunk
                        .intern_name(&self.qualify_stash_array_name(array));
                    self.compile_expr(index)?;
                    self.emit_op(Op::ExistsArrayElem(arr_idx), line, Some(root));
                } else if let ExprKind::ArrowDeref {
                    expr: container,
                    index,
                    kind: DerefKind::Hash,
                } = &inner.kind
                {
                    // Multi-level chains (e.g. `exists $h{x}{y}{z}`) need
                    // undef-tolerant intermediate eval — route through
                    // `ExistsExpr` (which calls `eval_exists_operand` and
                    // soft-fails on undef intermediates). (BUG-009)
                    if matches!(container.kind, ExprKind::ArrowDeref { .. }) {
                        let pool = self.chunk.add_exists_expr_entry(inner.as_ref().clone());
                        self.emit_op(Op::ExistsExpr(pool), line, Some(root));
                    } else {
                        self.compile_arrow_hash_base_expr(container)?;
                        self.compile_expr(index)?;
                        self.emit_op(Op::ExistsArrowHashElem, line, Some(root));
                    }
                } else if let ExprKind::ArrowDeref {
                    expr: container,
                    index,
                    kind: DerefKind::Array,
                } = &inner.kind
                {
                    if !arrow_deref_arrow_subscript_is_plain_scalar_index(index)
                        || matches!(container.kind, ExprKind::ArrowDeref { .. })
                    {
                        let pool = self.chunk.add_exists_expr_entry(inner.as_ref().clone());
                        self.emit_op(Op::ExistsExpr(pool), line, Some(root));
                    } else {
                        self.compile_expr(container)?;
                        self.compile_expr(index)?;
                        self.emit_op(Op::ExistsArrowArrayElem, line, Some(root));
                    }
                } else {
                    let pool = self.chunk.add_exists_expr_entry(inner.as_ref().clone());
                    self.emit_op(Op::ExistsExpr(pool), line, Some(root));
                }
            }
            ExprKind::Keys(inner) => {
                if let ExprKind::HashVar(name) = &inner.kind {
                    let idx = self.chunk.intern_name(name);
                    if ctx == WantarrayCtx::List {
                        self.emit_op(Op::HashKeys(idx), line, Some(root));
                    } else {
                        self.emit_op(Op::HashKeysScalar(idx), line, Some(root));
                    }
                } else {
                    self.compile_expr_ctx(inner, WantarrayCtx::List)?;
                    if ctx == WantarrayCtx::List {
                        self.emit_op(Op::KeysFromValue, line, Some(root));
                    } else {
                        self.emit_op(Op::KeysFromValueScalar, line, Some(root));
                    }
                }
            }
            ExprKind::Values(inner) => {
                if let ExprKind::HashVar(name) = &inner.kind {
                    let idx = self.chunk.intern_name(name);
                    if ctx == WantarrayCtx::List {
                        self.emit_op(Op::HashValues(idx), line, Some(root));
                    } else {
                        self.emit_op(Op::HashValuesScalar(idx), line, Some(root));
                    }
                } else {
                    self.compile_expr_ctx(inner, WantarrayCtx::List)?;
                    if ctx == WantarrayCtx::List {
                        self.emit_op(Op::ValuesFromValue, line, Some(root));
                    } else {
                        self.emit_op(Op::ValuesFromValueScalar, line, Some(root));
                    }
                }
            }
            ExprKind::Each(e) => {
                self.compile_expr(e)?;
                self.emit_op(Op::CallBuiltin(BuiltinId::Each as u16, 1), line, Some(root));
            }

            // ── Builtins that map to CallBuiltin ──
            ExprKind::Length(e) => {
                self.compile_expr(e)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Length as u16, 1),
                    line,
                    Some(root),
                );
            }
            ExprKind::Chomp(e) => {
                self.compile_expr(e)?;
                let lv = self.chunk.add_lvalue_expr(e.as_ref().clone());
                self.emit_op(Op::ChompInPlace(lv), line, Some(root));
            }
            ExprKind::Chop(e) => {
                self.compile_expr(e)?;
                let lv = self.chunk.add_lvalue_expr(e.as_ref().clone());
                self.emit_op(Op::ChopInPlace(lv), line, Some(root));
            }
            ExprKind::Defined(e) => {
                self.compile_expr(e)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Defined as u16, 1),
                    line,
                    Some(root),
                );
            }
            ExprKind::Abs(e) => {
                self.compile_expr(e)?;
                self.emit_op(Op::CallBuiltin(BuiltinId::Abs as u16, 1), line, Some(root));
            }
            ExprKind::Int(e) => {
                self.compile_expr(e)?;
                self.emit_op(Op::CallBuiltin(BuiltinId::Int as u16, 1), line, Some(root));
            }
            ExprKind::Sqrt(e) => {
                self.compile_expr(e)?;
                self.emit_op(Op::CallBuiltin(BuiltinId::Sqrt as u16, 1), line, Some(root));
            }
            ExprKind::Sin(e) => {
                self.compile_expr(e)?;
                self.emit_op(Op::CallBuiltin(BuiltinId::Sin as u16, 1), line, Some(root));
            }
            ExprKind::Cos(e) => {
                self.compile_expr(e)?;
                self.emit_op(Op::CallBuiltin(BuiltinId::Cos as u16, 1), line, Some(root));
            }
            ExprKind::Atan2 { y, x } => {
                self.compile_expr(y)?;
                self.compile_expr(x)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Atan2 as u16, 2),
                    line,
                    Some(root),
                );
            }
            ExprKind::Exp(e) => {
                self.compile_expr(e)?;
                self.emit_op(Op::CallBuiltin(BuiltinId::Exp as u16, 1), line, Some(root));
            }
            ExprKind::Log(e) => {
                self.compile_expr(e)?;
                self.emit_op(Op::CallBuiltin(BuiltinId::Log as u16, 1), line, Some(root));
            }
            ExprKind::Rand(upper) => {
                if let Some(e) = upper {
                    self.compile_expr(e)?;
                    self.emit_op(Op::CallBuiltin(BuiltinId::Rand as u16, 1), line, Some(root));
                } else {
                    self.emit_op(Op::CallBuiltin(BuiltinId::Rand as u16, 0), line, Some(root));
                }
            }
            ExprKind::Srand(seed) => {
                if let Some(e) = seed {
                    self.compile_expr(e)?;
                    self.emit_op(
                        Op::CallBuiltin(BuiltinId::Srand as u16, 1),
                        line,
                        Some(root),
                    );
                } else {
                    self.emit_op(
                        Op::CallBuiltin(BuiltinId::Srand as u16, 0),
                        line,
                        Some(root),
                    );
                }
            }
            ExprKind::Chr(e) => {
                self.compile_expr(e)?;
                self.emit_op(Op::CallBuiltin(BuiltinId::Chr as u16, 1), line, Some(root));
            }
            ExprKind::Ord(e) => {
                self.compile_expr(e)?;
                self.emit_op(Op::CallBuiltin(BuiltinId::Ord as u16, 1), line, Some(root));
            }
            ExprKind::Hex(e) => {
                self.compile_expr(e)?;
                self.emit_op(Op::CallBuiltin(BuiltinId::Hex as u16, 1), line, Some(root));
            }
            ExprKind::Oct(e) => {
                self.compile_expr(e)?;
                self.emit_op(Op::CallBuiltin(BuiltinId::Oct as u16, 1), line, Some(root));
            }
            ExprKind::Uc(e) => {
                self.compile_expr(e)?;
                self.emit_op(Op::CallBuiltin(BuiltinId::Uc as u16, 1), line, Some(root));
            }
            ExprKind::Lc(e) => {
                self.compile_expr(e)?;
                self.emit_op(Op::CallBuiltin(BuiltinId::Lc as u16, 1), line, Some(root));
            }
            ExprKind::Ucfirst(e) => {
                self.compile_expr(e)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Ucfirst as u16, 1),
                    line,
                    Some(root),
                );
            }
            ExprKind::Lcfirst(e) => {
                self.compile_expr(e)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Lcfirst as u16, 1),
                    line,
                    Some(root),
                );
            }
            ExprKind::Fc(e) => {
                self.compile_expr(e)?;
                self.emit_op(Op::CallBuiltin(BuiltinId::Fc as u16, 1), line, Some(root));
            }
            ExprKind::Crypt { plaintext, salt } => {
                self.compile_expr(plaintext)?;
                self.compile_expr(salt)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Crypt as u16, 2),
                    line,
                    Some(root),
                );
            }
            ExprKind::Pos(e) => match e {
                None => {
                    self.emit_op(Op::CallBuiltin(BuiltinId::Pos as u16, 0), line, Some(root));
                }
                Some(pos_arg) => {
                    if let ExprKind::ScalarVar(name) = &pos_arg.kind {
                        let stor = self.scalar_storage_name_for_ops(name);
                        let idx = self.chunk.add_constant(PerlValue::string(stor));
                        self.emit_op(Op::LoadConst(idx), line, Some(root));
                    } else {
                        self.compile_expr(pos_arg)?;
                    }
                    self.emit_op(Op::CallBuiltin(BuiltinId::Pos as u16, 1), line, Some(root));
                }
            },
            ExprKind::Study(e) => {
                self.compile_expr(e)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Study as u16, 1),
                    line,
                    Some(root),
                );
            }
            ExprKind::Ref(e) => {
                self.compile_expr(e)?;
                self.emit_op(Op::CallBuiltin(BuiltinId::Ref as u16, 1), line, Some(root));
            }
            ExprKind::Rev(e) => {
                // Compile in list context to get arrays/hashes as collections
                self.compile_expr_ctx(e, WantarrayCtx::List)?;
                if ctx == WantarrayCtx::List {
                    self.emit_op(Op::RevListOp, line, Some(root));
                } else {
                    self.emit_op(Op::RevScalarOp, line, Some(root));
                }
            }
            ExprKind::ReverseExpr(e) => {
                self.compile_expr_ctx(e, WantarrayCtx::List)?;
                if ctx == WantarrayCtx::List {
                    self.emit_op(Op::ReverseListOp, line, Some(root));
                } else {
                    self.emit_op(Op::ReverseScalarOp, line, Some(root));
                }
            }
            ExprKind::System(args) => {
                for a in args {
                    self.compile_expr(a)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::System as u16, args.len() as u8),
                    line,
                    Some(root),
                );
            }
            ExprKind::Exec(args) => {
                for a in args {
                    self.compile_expr(a)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Exec as u16, args.len() as u8),
                    line,
                    Some(root),
                );
            }

            // ── String builtins ──
            ExprKind::Substr {
                string,
                offset,
                length,
                replacement,
            } => {
                if let Some(rep) = replacement {
                    let idx = self.chunk.add_substr_four_arg_entry(
                        string.as_ref().clone(),
                        offset.as_ref().clone(),
                        length.as_ref().map(|b| b.as_ref().clone()),
                        rep.as_ref().clone(),
                    );
                    self.emit_op(Op::SubstrFourArg(idx), line, Some(root));
                } else {
                    self.compile_expr(string)?;
                    self.compile_expr(offset)?;
                    let mut argc: u8 = 2;
                    if let Some(len) = length {
                        self.compile_expr(len)?;
                        argc = 3;
                    }
                    self.emit_op(
                        Op::CallBuiltin(BuiltinId::Substr as u16, argc),
                        line,
                        Some(root),
                    );
                }
            }
            ExprKind::Index {
                string,
                substr,
                position,
            } => {
                self.compile_expr(string)?;
                self.compile_expr(substr)?;
                if let Some(pos) = position {
                    self.compile_expr(pos)?;
                    self.emit_op(
                        Op::CallBuiltin(BuiltinId::Index as u16, 3),
                        line,
                        Some(root),
                    );
                } else {
                    self.emit_op(
                        Op::CallBuiltin(BuiltinId::Index as u16, 2),
                        line,
                        Some(root),
                    );
                }
            }
            ExprKind::Rindex {
                string,
                substr,
                position,
            } => {
                self.compile_expr(string)?;
                self.compile_expr(substr)?;
                if let Some(pos) = position {
                    self.compile_expr(pos)?;
                    self.emit_op(
                        Op::CallBuiltin(BuiltinId::Rindex as u16, 3),
                        line,
                        Some(root),
                    );
                } else {
                    self.emit_op(
                        Op::CallBuiltin(BuiltinId::Rindex as u16, 2),
                        line,
                        Some(root),
                    );
                }
            }

            ExprKind::JoinExpr { separator, list } => {
                self.compile_expr(separator)?;
                // Arguments after the separator are evaluated in list context (Perl 5).
                self.compile_expr_ctx(list, WantarrayCtx::List)?;
                self.emit_op(Op::CallBuiltin(BuiltinId::Join as u16, 2), line, Some(root));
            }
            ExprKind::SplitExpr {
                pattern,
                string,
                limit,
            } => {
                self.compile_expr(pattern)?;
                self.compile_expr(string)?;
                if let Some(l) = limit {
                    self.compile_expr(l)?;
                    self.emit_op(
                        Op::CallBuiltin(BuiltinId::Split as u16, 3),
                        line,
                        Some(root),
                    );
                } else {
                    self.emit_op(
                        Op::CallBuiltin(BuiltinId::Split as u16, 2),
                        line,
                        Some(root),
                    );
                }
            }
            ExprKind::Sprintf { format, args } => {
                // sprintf's arg list after the format is Perl list context — ranges, arrays,
                // and `reverse`/`sort`/`grep` flatten into the format argument positions.
                self.compile_expr(format)?;
                for a in args {
                    self.compile_expr_ctx(a, WantarrayCtx::List)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Sprintf as u16, (1 + args.len()) as u8),
                    line,
                    Some(root),
                );
            }

            // ── I/O ──
            ExprKind::Open { handle, mode, file } => {
                if let ExprKind::OpenMyHandle { name } = &handle.kind {
                    let name_idx = self.chunk.intern_name(name);
                    self.emit_op(Op::LoadUndef, line, Some(root));
                    self.emit_declare_scalar(name_idx, line, false);
                    let h_idx = self.chunk.add_constant(PerlValue::string(name.clone()));
                    self.emit_op(Op::LoadConst(h_idx), line, Some(root));
                    self.compile_expr(mode)?;
                    if let Some(f) = file {
                        self.compile_expr(f)?;
                        self.emit_op(Op::CallBuiltin(BuiltinId::Open as u16, 3), line, Some(root));
                    } else {
                        self.emit_op(Op::CallBuiltin(BuiltinId::Open as u16, 2), line, Some(root));
                    }
                    self.emit_op(Op::SetScalarKeepPlain(name_idx), line, Some(root));
                    return Ok(());
                }
                self.compile_expr(handle)?;
                self.compile_expr(mode)?;
                if let Some(f) = file {
                    self.compile_expr(f)?;
                    self.emit_op(Op::CallBuiltin(BuiltinId::Open as u16, 3), line, Some(root));
                } else {
                    self.emit_op(Op::CallBuiltin(BuiltinId::Open as u16, 2), line, Some(root));
                }
            }
            ExprKind::OpenMyHandle { .. } => {
                return Err(CompileError::Unsupported(
                    "open my $fh handle expression".into(),
                ));
            }
            ExprKind::Close(e) => {
                self.compile_expr(e)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Close as u16, 1),
                    line,
                    Some(root),
                );
            }
            ExprKind::ReadLine(handle) => {
                let bid = if ctx == WantarrayCtx::List {
                    BuiltinId::ReadLineList
                } else {
                    BuiltinId::ReadLine
                };
                if let Some(h) = handle {
                    let idx = self.chunk.add_constant(PerlValue::string(h.clone()));
                    self.emit_op(Op::LoadConst(idx), line, Some(root));
                    self.emit_op(Op::CallBuiltin(bid as u16, 1), line, Some(root));
                } else {
                    self.emit_op(Op::CallBuiltin(bid as u16, 0), line, Some(root));
                }
            }
            ExprKind::Eof(e) => {
                if let Some(inner) = e {
                    self.compile_expr(inner)?;
                    self.emit_op(Op::CallBuiltin(BuiltinId::Eof as u16, 1), line, Some(root));
                } else {
                    self.emit_op(Op::CallBuiltin(BuiltinId::Eof as u16, 0), line, Some(root));
                }
            }
            ExprKind::Opendir { handle, path } => {
                self.compile_expr(handle)?;
                self.compile_expr(path)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Opendir as u16, 2),
                    line,
                    Some(root),
                );
            }
            ExprKind::Readdir(e) => {
                let bid = if ctx == WantarrayCtx::List {
                    BuiltinId::ReaddirList
                } else {
                    BuiltinId::Readdir
                };
                self.compile_expr(e)?;
                self.emit_op(Op::CallBuiltin(bid as u16, 1), line, Some(root));
            }
            ExprKind::Closedir(e) => {
                self.compile_expr(e)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Closedir as u16, 1),
                    line,
                    Some(root),
                );
            }
            ExprKind::Rewinddir(e) => {
                self.compile_expr(e)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Rewinddir as u16, 1),
                    line,
                    Some(root),
                );
            }
            ExprKind::Telldir(e) => {
                self.compile_expr(e)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Telldir as u16, 1),
                    line,
                    Some(root),
                );
            }
            ExprKind::Seekdir { handle, position } => {
                self.compile_expr(handle)?;
                self.compile_expr(position)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Seekdir as u16, 2),
                    line,
                    Some(root),
                );
            }

            // ── File tests ──
            ExprKind::FileTest { op, expr } => {
                self.compile_expr(expr)?;
                self.emit_op(Op::FileTestOp(*op as u8), line, Some(root));
            }

            // ── Eval / Do / Require ──
            ExprKind::Eval(e) => {
                self.compile_expr(e)?;
                // `eval { BLOCK }` runs synchronously and is intentionally
                // shared-state with the enclosing scope (it's used for error
                // catching, not stored as a closure value). Un-mark the
                // CodeRef's block so the closure-write check (DESIGN-001)
                // doesn't fire on writes to outer-scope `my` from inside
                // the eval body.
                if let ExprKind::CodeRef { .. } = &e.kind {
                    if let Some(max_idx) = self.sub_body_block_indices.iter().copied().max() {
                        self.sub_body_block_indices.remove(&max_idx);
                    }
                }
                self.emit_op(Op::CallBuiltin(BuiltinId::Eval as u16, 1), line, Some(root));
            }
            ExprKind::Do(e) => {
                // do { BLOCK } executes the block; do "file" loads a file
                if let ExprKind::CodeRef { body, .. } = &e.kind {
                    let block_idx = self.add_deferred_block(body.clone());
                    self.emit_op(Op::EvalBlock(block_idx, ctx.as_byte()), line, Some(root));
                } else {
                    self.compile_expr(e)?;
                    self.emit_op(Op::CallBuiltin(BuiltinId::Do as u16, 1), line, Some(root));
                }
            }
            ExprKind::Require(e) => {
                self.compile_expr(e)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Require as u16, 1),
                    line,
                    Some(root),
                );
            }

            // ── Filesystem ──
            ExprKind::Chdir(e) => {
                self.compile_expr(e)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Chdir as u16, 1),
                    line,
                    Some(root),
                );
            }
            ExprKind::Mkdir { path, mode } => {
                self.compile_expr(path)?;
                if let Some(m) = mode {
                    self.compile_expr(m)?;
                    self.emit_op(
                        Op::CallBuiltin(BuiltinId::Mkdir as u16, 2),
                        line,
                        Some(root),
                    );
                } else {
                    self.emit_op(
                        Op::CallBuiltin(BuiltinId::Mkdir as u16, 1),
                        line,
                        Some(root),
                    );
                }
            }
            ExprKind::Unlink(args) => {
                for a in args {
                    self.compile_expr(a)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Unlink as u16, args.len() as u8),
                    line,
                    Some(root),
                );
            }
            ExprKind::Rename { old, new } => {
                self.compile_expr(old)?;
                self.compile_expr(new)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Rename as u16, 2),
                    line,
                    Some(root),
                );
            }
            ExprKind::Chmod(args) => {
                for a in args {
                    self.compile_expr(a)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Chmod as u16, args.len() as u8),
                    line,
                    Some(root),
                );
            }
            ExprKind::Chown(args) => {
                for a in args {
                    self.compile_expr(a)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Chown as u16, args.len() as u8),
                    line,
                    Some(root),
                );
            }
            ExprKind::Stat(e) => {
                self.compile_expr(e)?;
                self.emit_op(Op::CallBuiltin(BuiltinId::Stat as u16, 1), line, Some(root));
            }
            ExprKind::Lstat(e) => {
                self.compile_expr(e)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Lstat as u16, 1),
                    line,
                    Some(root),
                );
            }
            ExprKind::Link { old, new } => {
                self.compile_expr(old)?;
                self.compile_expr(new)?;
                self.emit_op(Op::CallBuiltin(BuiltinId::Link as u16, 2), line, Some(root));
            }
            ExprKind::Symlink { old, new } => {
                self.compile_expr(old)?;
                self.compile_expr(new)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Symlink as u16, 2),
                    line,
                    Some(root),
                );
            }
            ExprKind::Readlink(e) => {
                self.compile_expr(e)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Readlink as u16, 1),
                    line,
                    Some(root),
                );
            }
            ExprKind::Files(args) => {
                for a in args {
                    self.compile_expr(a)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Files as u16, args.len() as u8),
                    line,
                    Some(root),
                );
            }
            ExprKind::Filesf(args) => {
                for a in args {
                    self.compile_expr(a)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Filesf as u16, args.len() as u8),
                    line,
                    Some(root),
                );
            }
            ExprKind::FilesfRecursive(args) => {
                for a in args {
                    self.compile_expr(a)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::FilesfRecursive as u16, args.len() as u8),
                    line,
                    Some(root),
                );
            }
            ExprKind::Dirs(args) => {
                for a in args {
                    self.compile_expr(a)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Dirs as u16, args.len() as u8),
                    line,
                    Some(root),
                );
            }
            ExprKind::DirsRecursive(args) => {
                for a in args {
                    self.compile_expr(a)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::DirsRecursive as u16, args.len() as u8),
                    line,
                    Some(root),
                );
            }
            ExprKind::SymLinks(args) => {
                for a in args {
                    self.compile_expr(a)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::SymLinks as u16, args.len() as u8),
                    line,
                    Some(root),
                );
            }
            ExprKind::Sockets(args) => {
                for a in args {
                    self.compile_expr(a)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Sockets as u16, args.len() as u8),
                    line,
                    Some(root),
                );
            }
            ExprKind::Pipes(args) => {
                for a in args {
                    self.compile_expr(a)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Pipes as u16, args.len() as u8),
                    line,
                    Some(root),
                );
            }
            ExprKind::BlockDevices(args) => {
                for a in args {
                    self.compile_expr(a)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::BlockDevices as u16, args.len() as u8),
                    line,
                    Some(root),
                );
            }
            ExprKind::CharDevices(args) => {
                for a in args {
                    self.compile_expr(a)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::CharDevices as u16, args.len() as u8),
                    line,
                    Some(root),
                );
            }
            ExprKind::Executables(args) => {
                for a in args {
                    self.compile_expr(a)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Executables as u16, args.len() as u8),
                    line,
                    Some(root),
                );
            }
            ExprKind::Glob(args) => {
                for a in args {
                    self.compile_expr(a)?;
                }
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Glob as u16, args.len() as u8),
                    line,
                    Some(root),
                );
            }
            ExprKind::GlobPar { args, progress } => {
                for a in args {
                    self.compile_expr(a)?;
                }
                match progress {
                    None => {
                        self.emit_op(
                            Op::CallBuiltin(BuiltinId::GlobPar as u16, args.len() as u8),
                            line,
                            Some(root),
                        );
                    }
                    Some(p) => {
                        self.compile_expr(p)?;
                        self.emit_op(
                            Op::CallBuiltin(
                                BuiltinId::GlobParProgress as u16,
                                (args.len() + 1) as u8,
                            ),
                            line,
                            Some(root),
                        );
                    }
                }
            }
            ExprKind::ParSed { args, progress } => {
                for a in args {
                    self.compile_expr(a)?;
                }
                match progress {
                    None => {
                        self.emit_op(
                            Op::CallBuiltin(BuiltinId::ParSed as u16, args.len() as u8),
                            line,
                            Some(root),
                        );
                    }
                    Some(p) => {
                        self.compile_expr(p)?;
                        self.emit_op(
                            Op::CallBuiltin(
                                BuiltinId::ParSedProgress as u16,
                                (args.len() + 1) as u8,
                            ),
                            line,
                            Some(root),
                        );
                    }
                }
            }

            // ── OOP ──
            ExprKind::Bless { ref_expr, class } => {
                self.compile_expr(ref_expr)?;
                if let Some(c) = class {
                    self.compile_expr(c)?;
                    self.emit_op(
                        Op::CallBuiltin(BuiltinId::Bless as u16, 2),
                        line,
                        Some(root),
                    );
                } else {
                    self.emit_op(
                        Op::CallBuiltin(BuiltinId::Bless as u16, 1),
                        line,
                        Some(root),
                    );
                }
            }
            ExprKind::Caller(e) => {
                if let Some(inner) = e {
                    self.compile_expr(inner)?;
                    self.emit_op(
                        Op::CallBuiltin(BuiltinId::Caller as u16, 1),
                        line,
                        Some(root),
                    );
                } else {
                    self.emit_op(
                        Op::CallBuiltin(BuiltinId::Caller as u16, 0),
                        line,
                        Some(root),
                    );
                }
            }
            ExprKind::Wantarray => {
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Wantarray as u16, 0),
                    line,
                    Some(root),
                );
            }

            // ── References ──
            ExprKind::ScalarRef(e) => match &e.kind {
                ExprKind::ScalarVar(name) => {
                    let idx = self.intern_scalar_var_for_ops(name);
                    self.emit_op(Op::MakeScalarBindingRef(idx), line, Some(root));
                }
                ExprKind::ArrayVar(name) => {
                    self.check_strict_array_access(name, line)?;
                    let idx = self.chunk.intern_name(&self.qualify_stash_array_name(name));
                    self.emit_op(Op::MakeArrayBindingRef(idx), line, Some(root));
                }
                ExprKind::HashVar(name) => {
                    self.check_strict_hash_access(name, line)?;
                    let idx = self.chunk.intern_name(name);
                    self.emit_op(Op::MakeHashBindingRef(idx), line, Some(root));
                }
                ExprKind::Deref {
                    expr: inner,
                    kind: Sigil::Array,
                } => {
                    self.compile_expr(inner)?;
                    self.emit_op(Op::MakeArrayRefAlias, line, Some(root));
                }
                ExprKind::Deref {
                    expr: inner,
                    kind: Sigil::Hash,
                } => {
                    self.compile_expr(inner)?;
                    self.emit_op(Op::MakeHashRefAlias, line, Some(root));
                }
                ExprKind::ArraySlice { .. } | ExprKind::HashSlice { .. } => {
                    self.compile_expr_ctx(e, WantarrayCtx::List)?;
                    self.emit_op(Op::MakeArrayRef, line, Some(root));
                }
                ExprKind::AnonymousListSlice { .. } | ExprKind::HashSliceDeref { .. } => {
                    self.compile_expr_ctx(e, WantarrayCtx::List)?;
                    self.emit_op(Op::MakeArrayRef, line, Some(root));
                }
                _ => {
                    self.compile_expr(e)?;
                    self.emit_op(Op::MakeScalarRef, line, Some(root));
                }
            },
            ExprKind::ArrayRef(elems) => {
                // `[ LIST ]` — each element is in list context so `1..5`, `reverse`, `grep`
                // and array variables flatten through [`Op::MakeArray`], which already splats
                // nested arrays.
                for e in elems {
                    self.compile_expr_ctx(e, WantarrayCtx::List)?;
                }
                self.emit_op(Op::MakeArray(elems.len() as u16), line, Some(root));
                self.emit_op(Op::MakeArrayRef, line, Some(root));
            }
            ExprKind::HashRef(pairs) => {
                // `{ K => V, ... }` — keys are scalar, values are list context so ranges and
                // slurpy constructs on the value side flatten into the built hash.
                // Special case: a single pair with the `__HASH_SPREAD__` sentinel key is
                // emitted by `parse_forced_hashref_body` (`+{ EXPR }`) and by the `{ %h }`
                // hash-spread short-form. Compile the value in list context and let
                // [`Op::MakeHashRef`] pair up the resulting list at runtime — the slow
                // path's [`Interpreter::eval_expr`] HashRef arm handles this too via the
                // same sentinel string.
                if pairs.len() == 1 {
                    if let ExprKind::String(ref k) = pairs[0].0.kind {
                        if k == "__HASH_SPREAD__" {
                            self.compile_expr_ctx(&pairs[0].1, WantarrayCtx::List)?;
                            self.emit_op(Op::MakeHashRef, line, Some(root));
                            return Ok(());
                        }
                    }
                }
                for (k, v) in pairs {
                    self.compile_expr(k)?;
                    self.compile_expr_ctx(v, WantarrayCtx::List)?;
                }
                self.emit_op(Op::MakeHash((pairs.len() * 2) as u16), line, Some(root));
                self.emit_op(Op::MakeHashRef, line, Some(root));
            }
            ExprKind::CodeRef { body, params } => {
                let block_idx = self.add_deferred_block(body.clone());
                self.sub_body_block_indices.insert(block_idx);
                // Stash params alongside the block index so the 4th-pass
                // compile can register them in the new sub-body layer (so
                // the closure-write check sees them as locally declared).
                while self.code_ref_block_params.len() <= block_idx as usize {
                    self.code_ref_block_params.push(Vec::new());
                }
                self.code_ref_block_params[block_idx as usize] = params.clone();
                let sig_idx = self.chunk.add_code_ref_sig(params.clone());
                self.emit_op(Op::MakeCodeRef(block_idx, sig_idx), line, Some(root));
            }
            ExprKind::SubroutineRef(name) => {
                // Unary `&name` — invoke subroutine with no explicit args (same as tree `call_named_sub`).
                let q = self.qualify_sub_key(name);
                let name_idx = self.chunk.intern_name(&q);
                self.emit_op(Op::Call(name_idx, 0, ctx.as_byte()), line, Some(root));
            }
            ExprKind::SubroutineCodeRef(name) => {
                // `\&name` — coderef (must exist at run time).
                let name_idx = self.chunk.intern_name(name);
                self.emit_op(Op::LoadNamedSubRef(name_idx), line, Some(root));
            }
            ExprKind::DynamicSubCodeRef(expr) => {
                self.compile_expr(expr)?;
                self.emit_op(Op::LoadDynamicSubRef, line, Some(root));
            }

            // ── Derefs ──
            ExprKind::ArrowDeref { expr, index, kind } => match kind {
                DerefKind::Array => {
                    self.compile_arrow_array_base_expr(expr)?;
                    let mut used_arrow_slice = false;
                    // `$r->[$i]` with a single plain-scalar subscript is element
                    // access, not a slice — even when the parser wraps it in a
                    // 1-element `List`. Returning a 1-element list here breaks
                    // arithmetic (`$a + $b` numifies via length to `1+1=2`).
                    if arrow_deref_arrow_subscript_is_plain_scalar_index(index) {
                        let inner = match &index.kind {
                            ExprKind::List(el) if el.len() == 1 => &el[0],
                            _ => index.as_ref(),
                        };
                        self.compile_expr(inner)?;
                        self.emit_op(Op::ArrowArray, line, Some(root));
                    } else if let ExprKind::List(indices) = &index.kind {
                        for ix in indices {
                            self.compile_array_slice_index_expr(ix)?;
                        }
                        self.emit_op(Op::ArrowArraySlice(indices.len() as u16), line, Some(root));
                        used_arrow_slice = true;
                    } else {
                        // One subscript expr may expand to multiple indices (`$r->[0..1]`, `[(0,1)]`).
                        self.compile_array_slice_index_expr(index)?;
                        self.emit_op(Op::ArrowArraySlice(1), line, Some(root));
                        used_arrow_slice = true;
                    }
                    if used_arrow_slice && ctx != WantarrayCtx::List {
                        self.emit_op(Op::ListSliceToScalar, line, Some(root));
                    }
                }
                DerefKind::Hash => {
                    self.compile_arrow_hash_base_expr(expr)?;
                    self.compile_expr(index)?;
                    self.emit_op(Op::ArrowHash, line, Some(root));
                }
                DerefKind::Call => {
                    self.compile_expr(expr)?;
                    // Always compile args in list context to preserve all arguments
                    self.compile_expr_ctx(index, WantarrayCtx::List)?;
                    self.emit_op(Op::ArrowCall(ctx.as_byte()), line, Some(root));
                }
            },
            ExprKind::Deref { expr, kind } => {
                // Perl: `scalar @{EXPR}` / `scalar @$r` is the array length (not a copy of the list).
                // `scalar %{EXPR}` uses hash fill metrics like `%h` in scalar context.
                if ctx != WantarrayCtx::List && matches!(kind, Sigil::Array) {
                    self.compile_expr(expr)?;
                    self.emit_op(Op::ArrayDerefLen, line, Some(root));
                } else if ctx != WantarrayCtx::List && matches!(kind, Sigil::Hash) {
                    self.compile_expr(expr)?;
                    self.emit_op(Op::SymbolicDeref(2), line, Some(root));
                    self.emit_op(Op::ValueScalarContext, line, Some(root));
                } else {
                    self.compile_expr(expr)?;
                    let b = match kind {
                        Sigil::Scalar => 0u8,
                        Sigil::Array => 1,
                        Sigil::Hash => 2,
                        Sigil::Typeglob => 3,
                    };
                    self.emit_op(Op::SymbolicDeref(b), line, Some(root));
                }
            }

            // ── Interpolated strings ──
            ExprKind::InterpolatedString(parts) => {
                // Check if any literal part contains case-escape sequences.
                let has_case_escapes = parts.iter().any(|p| {
                    if let StringPart::Literal(s) = p {
                        s.contains('\\')
                            && (s.contains("\\U")
                                || s.contains("\\L")
                                || s.contains("\\u")
                                || s.contains("\\l")
                                || s.contains("\\Q")
                                || s.contains("\\E"))
                    } else {
                        false
                    }
                });
                if parts.is_empty() {
                    let idx = self.chunk.add_constant(PerlValue::string(String::new()));
                    self.emit_op(Op::LoadConst(idx), line, Some(root));
                } else {
                    // `"$x"` is a single [`StringPart`] — still string context; must go through
                    // [`Op::Concat`] so operands are stringified (`use overload '""'`, etc.).
                    if !matches!(&parts[0], StringPart::Literal(_)) {
                        let idx = self.chunk.add_constant(PerlValue::string(String::new()));
                        self.emit_op(Op::LoadConst(idx), line, Some(root));
                    }
                    self.compile_string_part(&parts[0], line, Some(root))?;
                    for part in &parts[1..] {
                        self.compile_string_part(part, line, Some(root))?;
                        self.emit_op(Op::Concat, line, Some(root));
                    }
                    if !matches!(&parts[0], StringPart::Literal(_)) {
                        self.emit_op(Op::Concat, line, Some(root));
                    }
                }
                if has_case_escapes {
                    self.emit_op(Op::ProcessCaseEscapes, line, Some(root));
                }
            }

            // ── List ──
            ExprKind::List(exprs) => {
                if ctx == WantarrayCtx::Scalar {
                    // Perl: comma-list in scalar context evaluates to the **last** element (`(1,2)` → 2).
                    if let Some(last) = exprs.last() {
                        self.compile_expr_ctx(last, WantarrayCtx::Scalar)?;
                    } else {
                        self.emit_op(Op::LoadUndef, line, Some(root));
                    }
                } else {
                    for e in exprs {
                        self.compile_expr_ctx(e, ctx)?;
                    }
                    if exprs.len() != 1 {
                        self.emit_op(Op::MakeArray(exprs.len() as u16), line, Some(root));
                    }
                }
            }

            // ── QW ──
            ExprKind::QW(words) => {
                for w in words {
                    let idx = self.chunk.add_constant(PerlValue::string(w.clone()));
                    self.emit_op(Op::LoadConst(idx), line, Some(root));
                }
                self.emit_op(Op::MakeArray(words.len() as u16), line, Some(root));
            }

            // ── Postfix if/unless ──
            ExprKind::PostfixIf { expr, condition } => {
                self.compile_boolean_rvalue_condition(condition)?;
                let j = self.emit_op(Op::JumpIfFalse(0), line, Some(root));
                self.compile_expr(expr)?;
                let end = self.emit_op(Op::Jump(0), line, Some(root));
                self.chunk.patch_jump_here(j);
                self.emit_op(Op::LoadUndef, line, Some(root));
                self.chunk.patch_jump_here(end);
            }
            ExprKind::PostfixUnless { expr, condition } => {
                self.compile_boolean_rvalue_condition(condition)?;
                let j = self.emit_op(Op::JumpIfTrue(0), line, Some(root));
                self.compile_expr(expr)?;
                let end = self.emit_op(Op::Jump(0), line, Some(root));
                self.chunk.patch_jump_here(j);
                self.emit_op(Op::LoadUndef, line, Some(root));
                self.chunk.patch_jump_here(end);
            }

            // ── Postfix while/until/foreach ──
            ExprKind::PostfixWhile { expr, condition } => {
                // Detect `do { BLOCK } while (COND)` pattern
                let is_do_block = matches!(
                    &expr.kind,
                    ExprKind::Do(inner) if matches!(inner.kind, ExprKind::CodeRef { .. })
                );
                if is_do_block {
                    // do-while: body executes before first condition check
                    let loop_start = self.chunk.len();
                    self.compile_expr(expr)?;
                    self.emit_op(Op::Pop, line, Some(root));
                    self.compile_boolean_rvalue_condition(condition)?;
                    self.emit_op(Op::JumpIfTrue(loop_start), line, Some(root));
                    self.emit_op(Op::LoadUndef, line, Some(root));
                } else {
                    // Regular postfix while: condition checked first
                    let loop_start = self.chunk.len();
                    self.compile_boolean_rvalue_condition(condition)?;
                    let exit_jump = self.emit_op(Op::JumpIfFalse(0), line, Some(root));
                    self.compile_expr(expr)?;
                    self.emit_op(Op::Pop, line, Some(root));
                    self.emit_op(Op::Jump(loop_start), line, Some(root));
                    self.chunk.patch_jump_here(exit_jump);
                    self.emit_op(Op::LoadUndef, line, Some(root));
                }
            }
            ExprKind::PostfixUntil { expr, condition } => {
                let is_do_block = matches!(
                    &expr.kind,
                    ExprKind::Do(inner) if matches!(inner.kind, ExprKind::CodeRef { .. })
                );
                if is_do_block {
                    let loop_start = self.chunk.len();
                    self.compile_expr(expr)?;
                    self.emit_op(Op::Pop, line, Some(root));
                    self.compile_boolean_rvalue_condition(condition)?;
                    self.emit_op(Op::JumpIfFalse(loop_start), line, Some(root));
                    self.emit_op(Op::LoadUndef, line, Some(root));
                } else {
                    let loop_start = self.chunk.len();
                    self.compile_boolean_rvalue_condition(condition)?;
                    let exit_jump = self.emit_op(Op::JumpIfTrue(0), line, Some(root));
                    self.compile_expr(expr)?;
                    self.emit_op(Op::Pop, line, Some(root));
                    self.emit_op(Op::Jump(loop_start), line, Some(root));
                    self.chunk.patch_jump_here(exit_jump);
                    self.emit_op(Op::LoadUndef, line, Some(root));
                }
            }
            ExprKind::PostfixForeach { expr, list } => {
                self.compile_expr_ctx(list, WantarrayCtx::List)?;
                let list_name = self.chunk.intern_name("__pf_foreach_list__");
                self.emit_op(Op::DeclareArray(list_name), line, Some(root));
                let counter = self.chunk.intern_name("__pf_foreach_i__");
                self.emit_op(Op::LoadInt(0), line, Some(root));
                self.emit_op(Op::DeclareScalar(counter), line, Some(root));
                let underscore = self.chunk.intern_name("_");

                let loop_start = self.chunk.len();
                self.emit_get_scalar(counter, line, Some(root));
                self.emit_op(Op::ArrayLen(list_name), line, Some(root));
                self.emit_op(Op::NumLt, line, Some(root));
                let exit_jump = self.emit_op(Op::JumpIfFalse(0), line, Some(root));

                self.emit_get_scalar(counter, line, Some(root));
                self.emit_op(Op::GetArrayElem(list_name), line, Some(root));
                self.emit_set_scalar(underscore, line, Some(root));

                self.compile_expr(expr)?;
                self.emit_op(Op::Pop, line, Some(root));

                self.emit_pre_inc(counter, line, Some(root));
                self.emit_op(Op::Pop, line, Some(root));
                self.emit_op(Op::Jump(loop_start), line, Some(root));
                self.chunk.patch_jump_here(exit_jump);
                self.emit_op(Op::LoadUndef, line, Some(root));
            }

            ExprKind::AlgebraicMatch { subject, arms } => {
                let idx = self
                    .chunk
                    .add_algebraic_match_entry(subject.as_ref().clone(), arms.clone());
                self.emit_op(Op::AlgebraicMatch(idx), line, Some(root));
            }

            // ── Match (regex) ──
            ExprKind::Match {
                expr,
                pattern,
                flags,
                scalar_g,
                delim: _,
            } => {
                self.compile_expr(expr)?;
                let pat_idx = self.chunk.add_constant(PerlValue::string(pattern.clone()));
                let flags_idx = self.chunk.add_constant(PerlValue::string(flags.clone()));
                let pos_key_idx = if *scalar_g && flags.contains('g') {
                    if let ExprKind::ScalarVar(n) = &expr.kind {
                        let stor = self.scalar_storage_name_for_ops(n);
                        self.chunk.add_constant(PerlValue::string(stor))
                    } else {
                        u16::MAX
                    }
                } else {
                    u16::MAX
                };
                self.emit_op(
                    Op::RegexMatch(pat_idx, flags_idx, *scalar_g, pos_key_idx),
                    line,
                    Some(root),
                );
            }

            ExprKind::Substitution {
                expr,
                pattern,
                replacement,
                flags,
                delim: _,
            } => {
                self.compile_expr(expr)?;
                let pat_idx = self.chunk.add_constant(PerlValue::string(pattern.clone()));
                let repl_idx = self
                    .chunk
                    .add_constant(PerlValue::string(replacement.clone()));
                let flags_idx = self.chunk.add_constant(PerlValue::string(flags.clone()));
                let lv_idx = self.chunk.add_lvalue_expr(expr.as_ref().clone());
                self.emit_op(
                    Op::RegexSubst(pat_idx, repl_idx, flags_idx, lv_idx),
                    line,
                    Some(root),
                );
            }
            ExprKind::Transliterate {
                expr,
                from,
                to,
                flags,
                delim: _,
            } => {
                self.compile_expr(expr)?;
                let from_idx = self.chunk.add_constant(PerlValue::string(from.clone()));
                let to_idx = self.chunk.add_constant(PerlValue::string(to.clone()));
                let flags_idx = self.chunk.add_constant(PerlValue::string(flags.clone()));
                let lv_idx = self.chunk.add_lvalue_expr(expr.as_ref().clone());
                self.emit_op(
                    Op::RegexTransliterate(from_idx, to_idx, flags_idx, lv_idx),
                    line,
                    Some(root),
                );
            }

            // ── Regex literal ──
            ExprKind::Regex(pattern, flags) => {
                if ctx == WantarrayCtx::Void {
                    // Statement context: bare `/pat/;` is `$_ =~ /pat/` (Perl), not a discarded regex object.
                    self.compile_boolean_rvalue_condition(root)?;
                } else {
                    let pat_idx = self.chunk.add_constant(PerlValue::string(pattern.clone()));
                    let flags_idx = self.chunk.add_constant(PerlValue::string(flags.clone()));
                    self.emit_op(Op::LoadRegex(pat_idx, flags_idx), line, Some(root));
                }
            }

            // ── Map/Grep/Sort with blocks ──
            ExprKind::MapExpr {
                block,
                list,
                flatten_array_refs,
                stream,
            } => {
                self.compile_expr_ctx(list, WantarrayCtx::List)?;
                if *stream {
                    let block_idx = self.add_deferred_block(block.clone());
                    if *flatten_array_refs {
                        self.emit_op(Op::MapsFlatMapWithBlock(block_idx), line, Some(root));
                    } else {
                        self.emit_op(Op::MapsWithBlock(block_idx), line, Some(root));
                    }
                } else if let Some(k) = crate::map_grep_fast::detect_map_int_mul(block) {
                    self.emit_op(Op::MapIntMul(k), line, Some(root));
                } else {
                    let block_idx = self.add_deferred_block(block.clone());
                    if *flatten_array_refs {
                        self.emit_op(Op::FlatMapWithBlock(block_idx), line, Some(root));
                    } else {
                        self.emit_op(Op::MapWithBlock(block_idx), line, Some(root));
                    }
                }
                if ctx != WantarrayCtx::List {
                    self.emit_op(Op::StackArrayLen, line, Some(root));
                }
            }
            ExprKind::MapExprComma {
                expr,
                list,
                flatten_array_refs,
                stream,
            } => {
                self.compile_expr_ctx(list, WantarrayCtx::List)?;
                let idx = self.chunk.add_map_expr_entry(*expr.clone());
                if *stream {
                    if *flatten_array_refs {
                        self.emit_op(Op::MapsFlatMapWithExpr(idx), line, Some(root));
                    } else {
                        self.emit_op(Op::MapsWithExpr(idx), line, Some(root));
                    }
                } else if *flatten_array_refs {
                    self.emit_op(Op::FlatMapWithExpr(idx), line, Some(root));
                } else {
                    self.emit_op(Op::MapWithExpr(idx), line, Some(root));
                }
                if ctx != WantarrayCtx::List {
                    self.emit_op(Op::StackArrayLen, line, Some(root));
                }
            }
            ExprKind::ForEachExpr { block, list } => {
                self.compile_expr_ctx(list, WantarrayCtx::List)?;
                let block_idx = self.add_deferred_block(block.clone());
                self.emit_op(Op::ForEachWithBlock(block_idx), line, Some(root));
            }
            ExprKind::GrepExpr {
                block,
                list,
                keyword,
            } => {
                self.compile_expr_ctx(list, WantarrayCtx::List)?;
                if keyword.is_stream() {
                    let block_idx = self.add_deferred_block(block.clone());
                    self.emit_op(Op::FilterWithBlock(block_idx), line, Some(root));
                } else if let Some((m, r)) = crate::map_grep_fast::detect_grep_int_mod_eq(block) {
                    self.emit_op(Op::GrepIntModEq(m, r), line, Some(root));
                } else {
                    let block_idx = self.add_deferred_block(block.clone());
                    self.emit_op(Op::GrepWithBlock(block_idx), line, Some(root));
                }
                if ctx != WantarrayCtx::List {
                    self.emit_op(Op::StackArrayLen, line, Some(root));
                }
            }
            ExprKind::GrepExprComma {
                expr,
                list,
                keyword,
            } => {
                self.compile_expr_ctx(list, WantarrayCtx::List)?;
                let idx = self.chunk.add_grep_expr_entry(*expr.clone());
                if keyword.is_stream() {
                    self.emit_op(Op::FilterWithExpr(idx), line, Some(root));
                } else {
                    self.emit_op(Op::GrepWithExpr(idx), line, Some(root));
                }
                if ctx != WantarrayCtx::List {
                    self.emit_op(Op::StackArrayLen, line, Some(root));
                }
            }
            ExprKind::SortExpr { cmp, list } => {
                self.compile_expr_ctx(list, WantarrayCtx::List)?;
                match cmp {
                    Some(crate::ast::SortComparator::Block(block)) => {
                        if let Some(mode) = detect_sort_block_fast(block) {
                            let tag = match mode {
                                crate::sort_fast::SortBlockFast::Numeric => 0u8,
                                crate::sort_fast::SortBlockFast::String => 1u8,
                                crate::sort_fast::SortBlockFast::NumericRev => 2u8,
                                crate::sort_fast::SortBlockFast::StringRev => 3u8,
                            };
                            self.emit_op(Op::SortWithBlockFast(tag), line, Some(root));
                        } else {
                            let block_idx = self.add_deferred_block(block.clone());
                            self.register_sort_pair_block(block_idx);
                            self.emit_op(Op::SortWithBlock(block_idx), line, Some(root));
                        }
                    }
                    Some(crate::ast::SortComparator::Code(code_expr)) => {
                        self.compile_expr(code_expr)?;
                        self.emit_op(Op::SortWithCodeComparator(ctx.as_byte()), line, Some(root));
                    }
                    None => {
                        self.emit_op(Op::SortNoBlock, line, Some(root));
                    }
                }
            }

            // ── Parallel extensions ──
            ExprKind::PMapExpr {
                block,
                list,
                progress,
                flat_outputs,
                on_cluster,
                stream,
            } => {
                if *stream {
                    // Streaming: no progress flag needed, just list + block.
                    self.compile_expr_ctx(list, WantarrayCtx::List)?;
                    let block_idx = self.add_deferred_block(block.clone());
                    if *flat_outputs {
                        self.emit_op(Op::PFlatMapsWithBlock(block_idx), line, Some(root));
                    } else {
                        self.emit_op(Op::PMapsWithBlock(block_idx), line, Some(root));
                    }
                } else {
                    if let Some(p) = progress {
                        self.compile_expr(p)?;
                    } else {
                        self.emit_op(Op::LoadInt(0), line, Some(root));
                    }
                    self.compile_expr_ctx(list, WantarrayCtx::List)?;
                    if let Some(cluster_e) = on_cluster {
                        self.compile_expr(cluster_e)?;
                        let block_idx = self.add_deferred_block(block.clone());
                        self.emit_op(
                            Op::PMapRemote {
                                block_idx,
                                flat: u8::from(*flat_outputs),
                            },
                            line,
                            Some(root),
                        );
                    } else {
                        let block_idx = self.add_deferred_block(block.clone());
                        if *flat_outputs {
                            self.emit_op(Op::PFlatMapWithBlock(block_idx), line, Some(root));
                        } else {
                            self.emit_op(Op::PMapWithBlock(block_idx), line, Some(root));
                        }
                    }
                }
            }
            ExprKind::PMapChunkedExpr {
                chunk_size,
                block,
                list,
                progress,
            } => {
                if let Some(p) = progress {
                    self.compile_expr(p)?;
                } else {
                    self.emit_op(Op::LoadInt(0), line, Some(root));
                }
                self.compile_expr(chunk_size)?;
                self.compile_expr_ctx(list, WantarrayCtx::List)?;
                let block_idx = self.add_deferred_block(block.clone());
                self.emit_op(Op::PMapChunkedWithBlock(block_idx), line, Some(root));
            }
            ExprKind::PGrepExpr {
                block,
                list,
                progress,
                stream,
            } => {
                if *stream {
                    self.compile_expr_ctx(list, WantarrayCtx::List)?;
                    let block_idx = self.add_deferred_block(block.clone());
                    self.emit_op(Op::PGrepsWithBlock(block_idx), line, Some(root));
                } else {
                    if let Some(p) = progress {
                        self.compile_expr(p)?;
                    } else {
                        self.emit_op(Op::LoadInt(0), line, Some(root));
                    }
                    self.compile_expr_ctx(list, WantarrayCtx::List)?;
                    let block_idx = self.add_deferred_block(block.clone());
                    self.emit_op(Op::PGrepWithBlock(block_idx), line, Some(root));
                }
            }
            ExprKind::PForExpr {
                block,
                list,
                progress,
            } => {
                if let Some(p) = progress {
                    self.compile_expr(p)?;
                } else {
                    self.emit_op(Op::LoadInt(0), line, Some(root));
                }
                self.compile_expr_ctx(list, WantarrayCtx::List)?;
                let block_idx = self.add_deferred_block(block.clone());
                self.emit_op(Op::PForWithBlock(block_idx), line, Some(root));
            }
            ExprKind::ParLinesExpr {
                path,
                callback,
                progress,
            } => {
                let idx = self.chunk.add_par_lines_entry(
                    path.as_ref().clone(),
                    callback.as_ref().clone(),
                    progress.as_ref().map(|p| p.as_ref().clone()),
                );
                self.emit_op(Op::ParLines(idx), line, Some(root));
            }
            ExprKind::ParWalkExpr {
                path,
                callback,
                progress,
            } => {
                let idx = self.chunk.add_par_walk_entry(
                    path.as_ref().clone(),
                    callback.as_ref().clone(),
                    progress.as_ref().map(|p| p.as_ref().clone()),
                );
                self.emit_op(Op::ParWalk(idx), line, Some(root));
            }
            ExprKind::PwatchExpr { path, callback } => {
                let idx = self
                    .chunk
                    .add_pwatch_entry(path.as_ref().clone(), callback.as_ref().clone());
                self.emit_op(Op::Pwatch(idx), line, Some(root));
            }
            ExprKind::PSortExpr {
                cmp,
                list,
                progress,
            } => {
                if let Some(p) = progress {
                    self.compile_expr(p)?;
                } else {
                    self.emit_op(Op::LoadInt(0), line, Some(root));
                }
                self.compile_expr_ctx(list, WantarrayCtx::List)?;
                if let Some(block) = cmp {
                    if let Some(mode) = detect_sort_block_fast(block) {
                        let tag = match mode {
                            crate::sort_fast::SortBlockFast::Numeric => 0u8,
                            crate::sort_fast::SortBlockFast::String => 1u8,
                            crate::sort_fast::SortBlockFast::NumericRev => 2u8,
                            crate::sort_fast::SortBlockFast::StringRev => 3u8,
                        };
                        self.emit_op(Op::PSortWithBlockFast(tag), line, Some(root));
                    } else {
                        let block_idx = self.add_deferred_block(block.clone());
                        self.register_sort_pair_block(block_idx);
                        self.emit_op(Op::PSortWithBlock(block_idx), line, Some(root));
                    }
                } else {
                    self.emit_op(Op::PSortNoBlockParallel, line, Some(root));
                }
            }
            ExprKind::ReduceExpr { block, list } => {
                self.compile_expr_ctx(list, WantarrayCtx::List)?;
                let block_idx = self.add_deferred_block(block.clone());
                self.register_sort_pair_block(block_idx);
                self.emit_op(Op::ReduceWithBlock(block_idx), line, Some(root));
            }
            ExprKind::PReduceExpr {
                block,
                list,
                progress,
            } => {
                if let Some(p) = progress {
                    self.compile_expr(p)?;
                } else {
                    self.emit_op(Op::LoadInt(0), line, Some(root));
                }
                self.compile_expr_ctx(list, WantarrayCtx::List)?;
                let block_idx = self.add_deferred_block(block.clone());
                self.register_sort_pair_block(block_idx);
                self.emit_op(Op::PReduceWithBlock(block_idx), line, Some(root));
            }
            ExprKind::PReduceInitExpr {
                init,
                block,
                list,
                progress,
            } => {
                if let Some(p) = progress {
                    self.compile_expr(p)?;
                } else {
                    self.emit_op(Op::LoadInt(0), line, Some(root));
                }
                self.compile_expr_ctx(list, WantarrayCtx::List)?;
                self.compile_expr(init)?;
                let block_idx = self.add_deferred_block(block.clone());
                self.emit_op(Op::PReduceInitWithBlock(block_idx), line, Some(root));
            }
            ExprKind::PMapReduceExpr {
                map_block,
                reduce_block,
                list,
                progress,
            } => {
                if let Some(p) = progress {
                    self.compile_expr(p)?;
                } else {
                    self.emit_op(Op::LoadInt(0), line, Some(root));
                }
                self.compile_expr_ctx(list, WantarrayCtx::List)?;
                let map_idx = self.add_deferred_block(map_block.clone());
                let reduce_idx = self.add_deferred_block(reduce_block.clone());
                self.emit_op(
                    Op::PMapReduceWithBlocks(map_idx, reduce_idx),
                    line,
                    Some(root),
                );
            }
            ExprKind::PcacheExpr {
                block,
                list,
                progress,
            } => {
                if let Some(p) = progress {
                    self.compile_expr(p)?;
                } else {
                    self.emit_op(Op::LoadInt(0), line, Some(root));
                }
                self.compile_expr_ctx(list, WantarrayCtx::List)?;
                let block_idx = self.add_deferred_block(block.clone());
                self.emit_op(Op::PcacheWithBlock(block_idx), line, Some(root));
            }
            ExprKind::PselectExpr { receivers, timeout } => {
                let n = receivers.len();
                if n > u8::MAX as usize {
                    return Err(CompileError::Unsupported(
                        "pselect: too many receivers".into(),
                    ));
                }
                for r in receivers {
                    self.compile_expr(r)?;
                }
                let has_timeout = timeout.is_some();
                if let Some(t) = timeout {
                    self.compile_expr(t)?;
                }
                self.emit_op(
                    Op::Pselect {
                        n_rx: n as u8,
                        has_timeout,
                    },
                    line,
                    Some(root),
                );
            }
            ExprKind::FanExpr {
                count,
                block,
                progress,
                capture,
            } => {
                if let Some(p) = progress {
                    self.compile_expr(p)?;
                } else {
                    self.emit_op(Op::LoadInt(0), line, Some(root));
                }
                let block_idx = self.add_deferred_block(block.clone());
                match (count, capture) {
                    (Some(c), false) => {
                        self.compile_expr(c)?;
                        self.emit_op(Op::FanWithBlock(block_idx), line, Some(root));
                    }
                    (None, false) => {
                        self.emit_op(Op::FanWithBlockAuto(block_idx), line, Some(root));
                    }
                    (Some(c), true) => {
                        self.compile_expr(c)?;
                        self.emit_op(Op::FanCapWithBlock(block_idx), line, Some(root));
                    }
                    (None, true) => {
                        self.emit_op(Op::FanCapWithBlockAuto(block_idx), line, Some(root));
                    }
                }
            }
            ExprKind::AsyncBlock { body } | ExprKind::SpawnBlock { body } => {
                let block_idx = self.add_deferred_block(body.clone());
                self.emit_op(Op::AsyncBlock(block_idx), line, Some(root));
            }
            ExprKind::Trace { body } => {
                let block_idx = self.add_deferred_block(body.clone());
                self.emit_op(Op::TraceBlock(block_idx), line, Some(root));
            }
            ExprKind::Timer { body } => {
                let block_idx = self.add_deferred_block(body.clone());
                self.emit_op(Op::TimerBlock(block_idx), line, Some(root));
            }
            ExprKind::Bench { body, times } => {
                self.compile_expr(times)?;
                let block_idx = self.add_deferred_block(body.clone());
                self.emit_op(Op::BenchBlock(block_idx), line, Some(root));
            }
            ExprKind::Await(e) => {
                self.compile_expr(e)?;
                self.emit_op(Op::Await, line, Some(root));
            }
            ExprKind::Slurp(e) => {
                self.compile_expr(e)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Slurp as u16, 1),
                    line,
                    Some(root),
                );
            }
            ExprKind::Capture(e) => {
                self.compile_expr(e)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Capture as u16, 1),
                    line,
                    Some(root),
                );
            }
            ExprKind::Qx(e) => {
                self.compile_expr(e)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::Readpipe as u16, 1),
                    line,
                    Some(root),
                );
            }
            ExprKind::FetchUrl(e) => {
                self.compile_expr(e)?;
                self.emit_op(
                    Op::CallBuiltin(BuiltinId::FetchUrl as u16, 1),
                    line,
                    Some(root),
                );
            }
            ExprKind::Pchannel { capacity } => {
                if let Some(c) = capacity {
                    self.compile_expr(c)?;
                    self.emit_op(
                        Op::CallBuiltin(BuiltinId::Pchannel as u16, 1),
                        line,
                        Some(root),
                    );
                } else {
                    self.emit_op(
                        Op::CallBuiltin(BuiltinId::Pchannel as u16, 0),
                        line,
                        Some(root),
                    );
                }
            }
            ExprKind::RetryBlock { .. }
            | ExprKind::RateLimitBlock { .. }
            | ExprKind::EveryBlock { .. }
            | ExprKind::GenBlock { .. }
            | ExprKind::Yield(_)
            | ExprKind::Spinner { .. } => {
                let idx = self.chunk.ast_eval_exprs.len() as u16;
                self.chunk.ast_eval_exprs.push(root.clone());
                self.emit_op(Op::EvalAstExpr(idx), line, Some(root));
            }
            ExprKind::MyExpr { keyword, decls } => {
                // `my $x = EXPR` in expression context (e.g. `while (my $line = <$fh>)`)
                // Compile the declaration, then leave the value on the stack for the caller.
                if decls.len() == 1 && decls[0].sigil == Sigil::Scalar {
                    let decl = &decls[0];
                    if let Some(init) = &decl.initializer {
                        self.compile_expr(init)?;
                    } else {
                        self.chunk.emit(Op::LoadUndef, line);
                    }
                    // Dup so the value stays on stack after DeclareScalar consumes one copy
                    self.emit_op(Op::Dup, line, Some(root));
                    let name_idx = self.chunk.intern_name(&decl.name);
                    match keyword.as_str() {
                        "state" => {
                            let name = self.chunk.names[name_idx as usize].clone();
                            self.register_declare(Sigil::Scalar, &name, false);
                            self.chunk.emit(Op::DeclareStateScalar(name_idx), line);
                        }
                        _ => {
                            self.emit_declare_scalar(name_idx, line, false);
                        }
                    }
                } else {
                    return Err(CompileError::Unsupported(
                        "my/our/state/local in expression context with multiple or non-scalar decls".into(),
                    ));
                }
            }
        }
        Ok(())
    }

    fn compile_string_part(
        &mut self,
        part: &StringPart,
        line: usize,
        parent: Option<&Expr>,
    ) -> Result<(), CompileError> {
        match part {
            StringPart::Literal(s) => {
                let idx = self.chunk.add_constant(PerlValue::string(s.clone()));
                self.emit_op(Op::LoadConst(idx), line, parent);
            }
            StringPart::ScalarVar(name) => {
                let idx = self.intern_scalar_var_for_ops(name);
                self.emit_get_scalar(idx, line, parent);
            }
            StringPart::ArrayVar(name) => {
                let idx = self.chunk.intern_name(&self.qualify_stash_array_name(name));
                self.emit_op(Op::GetArray(idx), line, parent);
                self.emit_op(Op::ArrayStringifyListSep, line, parent);
            }
            StringPart::Expr(e) => {
                // Interpolation uses list/array values (`$"`), not Perl scalar(@arr) length.
                if matches!(&e.kind, ExprKind::ArraySlice { .. })
                    || matches!(
                        &e.kind,
                        ExprKind::Deref {
                            kind: Sigil::Array,
                            ..
                        }
                    )
                {
                    self.compile_expr_ctx(e, WantarrayCtx::List)?;
                    self.emit_op(Op::ArrayStringifyListSep, line, parent);
                } else {
                    self.compile_expr(e)?;
                }
            }
        }
        Ok(())
    }

    fn compile_assign(
        &mut self,
        target: &Expr,
        line: usize,
        keep: bool,
        ast: Option<&Expr>,
    ) -> Result<(), CompileError> {
        match &target.kind {
            ExprKind::ScalarVar(name) => {
                self.check_strict_scalar_access(name, line)?;
                self.check_scalar_mutable(name, line)?;
                self.check_closure_write_to_outer_my(name, line)?;
                let idx = self.intern_scalar_var_for_ops(name);
                if keep {
                    self.emit_set_scalar_keep(idx, line, ast);
                } else {
                    self.emit_set_scalar(idx, line, ast);
                }
            }
            ExprKind::ArrayVar(name) => {
                self.check_strict_array_access(name, line)?;
                let q = self.qualify_stash_array_name(name);
                self.check_array_mutable(&q, line)?;
                let idx = self.chunk.intern_name(&q);
                self.emit_op(Op::SetArray(idx), line, ast);
                if keep {
                    self.emit_op(Op::GetArray(idx), line, ast);
                }
            }
            ExprKind::HashVar(name) => {
                self.check_strict_hash_access(name, line)?;
                self.check_hash_mutable(name, line)?;
                let idx = self.chunk.intern_name(name);
                self.emit_op(Op::SetHash(idx), line, ast);
                if keep {
                    self.emit_op(Op::GetHash(idx), line, ast);
                }
            }
            ExprKind::ArrayElement { array, index } => {
                self.check_strict_array_access(array, line)?;
                let q = self.qualify_stash_array_name(array);
                self.check_array_mutable(&q, line)?;
                let idx = self.chunk.intern_name(&q);
                self.compile_expr(index)?;
                self.emit_op(Op::SetArrayElem(idx), line, ast);
            }
            ExprKind::ArraySlice { array, indices } => {
                if indices.is_empty() {
                    if self.is_mysync_array(array) {
                        return Err(CompileError::Unsupported(
                            "mysync array slice assign".into(),
                        ));
                    }
                    self.check_strict_array_access(array, line)?;
                    let q = self.qualify_stash_array_name(array);
                    self.check_array_mutable(&q, line)?;
                    let arr_idx = self.chunk.intern_name(&q);
                    self.emit_op(Op::SetNamedArraySlice(arr_idx, 0), line, ast);
                    if keep {
                        self.emit_op(Op::MakeArray(0), line, ast);
                    }
                    return Ok(());
                }
                if self.is_mysync_array(array) {
                    return Err(CompileError::Unsupported(
                        "mysync array slice assign".into(),
                    ));
                }
                self.check_strict_array_access(array, line)?;
                let q = self.qualify_stash_array_name(array);
                self.check_array_mutable(&q, line)?;
                let arr_idx = self.chunk.intern_name(&q);
                for ix in indices {
                    self.compile_array_slice_index_expr(ix)?;
                }
                self.emit_op(
                    Op::SetNamedArraySlice(arr_idx, indices.len() as u16),
                    line,
                    ast,
                );
                if keep {
                    for (ix, index_expr) in indices.iter().enumerate() {
                        self.compile_array_slice_index_expr(index_expr)?;
                        self.emit_op(Op::ArraySlicePart(arr_idx), line, ast);
                        if ix > 0 {
                            self.emit_op(Op::ArrayConcatTwo, line, ast);
                        }
                    }
                }
                return Ok(());
            }
            ExprKind::HashElement { hash, key } => {
                self.check_strict_hash_access(hash, line)?;
                self.check_hash_mutable(hash, line)?;
                let idx = self.chunk.intern_name(hash);
                self.compile_expr(key)?;
                if keep {
                    self.emit_op(Op::SetHashElemKeep(idx), line, ast);
                } else {
                    self.emit_op(Op::SetHashElem(idx), line, ast);
                }
            }
            ExprKind::HashSlice { hash, keys } => {
                if keys.is_empty() {
                    if self.is_mysync_hash(hash) {
                        return Err(CompileError::Unsupported("mysync hash slice assign".into()));
                    }
                    self.check_strict_hash_access(hash, line)?;
                    self.check_hash_mutable(hash, line)?;
                    let hash_idx = self.chunk.intern_name(hash);
                    self.emit_op(Op::SetHashSlice(hash_idx, 0), line, ast);
                    if keep {
                        self.emit_op(Op::MakeArray(0), line, ast);
                    }
                    return Ok(());
                }
                if self.is_mysync_hash(hash) {
                    return Err(CompileError::Unsupported("mysync hash slice assign".into()));
                }
                self.check_strict_hash_access(hash, line)?;
                self.check_hash_mutable(hash, line)?;
                let hash_idx = self.chunk.intern_name(hash);
                // Multi-key entries (`'a'..'c'`, `qw/a b/`, list literals) push an array value;
                // [`Self::assign_named_hash_slice`] / [`crate::bytecode::Op::SetHashSlice`]
                // flattens it at runtime, so compile in list context (scalar context collapses
                // `..` to a flip-flop).
                for key_expr in keys {
                    self.compile_hash_slice_key_expr(key_expr)?;
                }
                self.emit_op(Op::SetHashSlice(hash_idx, keys.len() as u16), line, ast);
                if keep {
                    for key_expr in keys {
                        self.compile_expr(key_expr)?;
                        self.emit_op(Op::GetHashElem(hash_idx), line, ast);
                    }
                    self.emit_op(Op::MakeArray(keys.len() as u16), line, ast);
                }
                return Ok(());
            }
            ExprKind::Deref {
                expr,
                kind: Sigil::Scalar,
            } => {
                self.compile_expr(expr)?;
                if keep {
                    self.emit_op(Op::SetSymbolicScalarRefKeep, line, ast);
                } else {
                    self.emit_op(Op::SetSymbolicScalarRef, line, ast);
                }
            }
            ExprKind::Deref {
                expr,
                kind: Sigil::Array,
            } => {
                self.compile_expr(expr)?;
                self.emit_op(Op::SetSymbolicArrayRef, line, ast);
            }
            ExprKind::Deref {
                expr,
                kind: Sigil::Hash,
            } => {
                self.compile_expr(expr)?;
                self.emit_op(Op::SetSymbolicHashRef, line, ast);
            }
            ExprKind::Deref {
                expr,
                kind: Sigil::Typeglob,
            } => {
                self.compile_expr(expr)?;
                self.emit_op(Op::SetSymbolicTypeglobRef, line, ast);
            }
            ExprKind::Typeglob(name) => {
                let idx = self.chunk.intern_name(name);
                if keep {
                    self.emit_op(Op::TypeglobAssignFromValue(idx), line, ast);
                } else {
                    return Err(CompileError::Unsupported(
                        "typeglob assign without keep (internal)".into(),
                    ));
                }
            }
            ExprKind::AnonymousListSlice { source, indices } => {
                if let ExprKind::Deref {
                    expr: inner,
                    kind: Sigil::Array,
                } = &source.kind
                {
                    if indices.is_empty() {
                        return Err(CompileError::Unsupported(
                            "assign to empty list slice (internal)".into(),
                        ));
                    }
                    self.compile_arrow_array_base_expr(inner)?;
                    for ix in indices {
                        self.compile_array_slice_index_expr(ix)?;
                    }
                    self.emit_op(Op::SetArrowArraySlice(indices.len() as u16), line, ast);
                    if keep {
                        self.compile_arrow_array_base_expr(inner)?;
                        for ix in indices {
                            self.compile_array_slice_index_expr(ix)?;
                        }
                        self.emit_op(Op::ArrowArraySlice(indices.len() as u16), line, ast);
                    }
                    return Ok(());
                }
                return Err(CompileError::Unsupported(
                    "assign to anonymous list slice (non-@array-deref base)".into(),
                ));
            }
            ExprKind::ArrowDeref {
                expr,
                index,
                kind: DerefKind::Hash,
            } => {
                self.compile_arrow_hash_base_expr(expr)?;
                self.compile_expr(index)?;
                if keep {
                    self.emit_op(Op::SetArrowHashKeep, line, ast);
                } else {
                    self.emit_op(Op::SetArrowHash, line, ast);
                }
            }
            ExprKind::ArrowDeref {
                expr,
                index,
                kind: DerefKind::Array,
            } => {
                if let ExprKind::List(indices) = &index.kind {
                    // Multi-index slice assignment: RHS value is already on the stack (pushed
                    // by the enclosing `compile_expr(value)` before `compile_assign` was called
                    // with keep = true). `SetArrowArraySlice` delegates to
                    // `Interpreter::assign_arrow_array_slice` for element-wise write.
                    self.compile_arrow_array_base_expr(expr)?;
                    for ix in indices {
                        self.compile_array_slice_index_expr(ix)?;
                    }
                    self.emit_op(Op::SetArrowArraySlice(indices.len() as u16), line, ast);
                    if keep {
                        // The Set op pops the value; keep callers re-read via a fresh slice read.
                        self.compile_arrow_array_base_expr(expr)?;
                        for ix in indices {
                            self.compile_array_slice_index_expr(ix)?;
                        }
                        self.emit_op(Op::ArrowArraySlice(indices.len() as u16), line, ast);
                    }
                    return Ok(());
                }
                if arrow_deref_arrow_subscript_is_plain_scalar_index(index) {
                    self.compile_arrow_array_base_expr(expr)?;
                    self.compile_expr(index)?;
                    if keep {
                        self.emit_op(Op::SetArrowArrayKeep, line, ast);
                    } else {
                        self.emit_op(Op::SetArrowArray, line, ast);
                    }
                } else {
                    self.compile_arrow_array_base_expr(expr)?;
                    self.compile_array_slice_index_expr(index)?;
                    self.emit_op(Op::SetArrowArraySlice(1), line, ast);
                    if keep {
                        self.compile_arrow_array_base_expr(expr)?;
                        self.compile_array_slice_index_expr(index)?;
                        self.emit_op(Op::ArrowArraySlice(1), line, ast);
                    }
                }
            }
            ExprKind::ArrowDeref {
                kind: DerefKind::Call,
                ..
            } => {
                return Err(CompileError::Unsupported(
                    "Assign to arrow call deref".into(),
                ));
            }
            ExprKind::HashSliceDeref { container, keys } => {
                self.compile_expr(container)?;
                for key_expr in keys {
                    self.compile_hash_slice_key_expr(key_expr)?;
                }
                self.emit_op(Op::SetHashSliceDeref(keys.len() as u16), line, ast);
            }
            ExprKind::Pos(inner) => {
                let Some(inner_e) = inner.as_ref() else {
                    return Err(CompileError::Unsupported(
                        "assign to pos() without scalar".into(),
                    ));
                };
                if keep {
                    self.emit_op(Op::Dup, line, ast);
                }
                match &inner_e.kind {
                    ExprKind::ScalarVar(name) => {
                        let stor = self.scalar_storage_name_for_ops(name);
                        let idx = self.chunk.add_constant(PerlValue::string(stor));
                        self.emit_op(Op::LoadConst(idx), line, ast);
                    }
                    _ => {
                        self.compile_expr(inner_e)?;
                    }
                }
                self.emit_op(Op::SetRegexPos, line, ast);
            }
            // List assignment: `($a, $b) = (val1, val2)` — RHS is on stack as array,
            // store into temp, then distribute elements to each target.
            ExprKind::List(targets) => {
                let tmp = self.chunk.intern_name("__list_assign_swap__");
                self.emit_op(Op::DeclareArray(tmp), line, ast);
                for (i, t) in targets.iter().enumerate() {
                    self.emit_op(Op::LoadInt(i as i64), line, ast);
                    self.emit_op(Op::GetArrayElem(tmp), line, ast);
                    self.compile_assign(t, line, false, ast)?;
                }
                if keep {
                    self.emit_op(Op::GetArray(tmp), line, ast);
                }
            }
            _ => {
                return Err(CompileError::Unsupported("Assign to complex lvalue".into()));
            }
        }
        Ok(())
    }
}

/// Map a binary op to its stack opcode for compound assignment on aggregates (`$a[$i]`, `$h{$k}`).
pub(crate) fn binop_to_vm_op(op: BinOp) -> Option<Op> {
    Some(match op {
        BinOp::Add => Op::Add,
        BinOp::Sub => Op::Sub,
        BinOp::Mul => Op::Mul,
        BinOp::Div => Op::Div,
        BinOp::Mod => Op::Mod,
        BinOp::Pow => Op::Pow,
        BinOp::Concat => Op::Concat,
        BinOp::BitAnd => Op::BitAnd,
        BinOp::BitOr => Op::BitOr,
        BinOp::BitXor => Op::BitXor,
        BinOp::ShiftLeft => Op::Shl,
        BinOp::ShiftRight => Op::Shr,
        _ => return None,
    })
}

/// Encode/decode scalar compound ops for [`Op::ScalarCompoundAssign`].
pub(crate) fn scalar_compound_op_to_byte(op: BinOp) -> Option<u8> {
    Some(match op {
        BinOp::Add => 0,
        BinOp::Sub => 1,
        BinOp::Mul => 2,
        BinOp::Div => 3,
        BinOp::Mod => 4,
        BinOp::Pow => 5,
        BinOp::Concat => 6,
        BinOp::BitAnd => 7,
        BinOp::BitOr => 8,
        BinOp::BitXor => 9,
        BinOp::ShiftLeft => 10,
        BinOp::ShiftRight => 11,
        _ => return None,
    })
}

pub(crate) fn scalar_compound_op_from_byte(b: u8) -> Option<BinOp> {
    Some(match b {
        0 => BinOp::Add,
        1 => BinOp::Sub,
        2 => BinOp::Mul,
        3 => BinOp::Div,
        4 => BinOp::Mod,
        5 => BinOp::Pow,
        6 => BinOp::Concat,
        7 => BinOp::BitAnd,
        8 => BinOp::BitOr,
        9 => BinOp::BitXor,
        10 => BinOp::ShiftLeft,
        11 => BinOp::ShiftRight,
        _ => return None,
    })
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::bytecode::{BuiltinId, Op, GP_RUN};
    use crate::parse;

    fn compile_snippet(code: &str) -> Result<Chunk, CompileError> {
        let program = parse(code).expect("parse snippet");
        Compiler::new().compile_program(&program)
    }

    fn assert_last_halt(chunk: &Chunk) {
        assert!(
            matches!(chunk.ops.last(), Some(Op::Halt)),
            "expected Halt last, got {:?}",
            chunk.ops.last()
        );
    }

    #[test]
    fn compile_empty_program_emits_run_phase_then_halt() {
        let chunk = compile_snippet("").expect("compile");
        assert_eq!(chunk.ops.len(), 2);
        assert!(matches!(chunk.ops[0], Op::SetGlobalPhase(p) if p == GP_RUN));
        assert!(matches!(chunk.ops[1], Op::Halt));
    }

    #[test]
    fn compile_integer_literal_statement() {
        let chunk = compile_snippet("42;").expect("compile");
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::LoadInt(42))));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_pos_assign_emits_set_regex_pos() {
        let chunk = compile_snippet(r#"$_ = ""; pos = 3;"#).expect("compile");
        assert!(
            chunk.ops.iter().any(|o| matches!(o, Op::SetRegexPos)),
            "expected SetRegexPos in {:?}",
            chunk.ops
        );
    }

    #[test]
    fn compile_pos_deref_scalar_assign_emits_set_regex_pos() {
        let chunk = compile_snippet(
            r#"no strict 'vars';
            my $s;
            my $r = \$s;
            pos $$r = 0;"#,
        )
        .expect("compile");
        assert!(
            chunk.ops.iter().any(|o| matches!(o, Op::SetRegexPos)),
            r"expected SetRegexPos for pos $$r =, got {:?}",
            chunk.ops
        );
    }

    #[test]
    fn compile_map_expr_comma_emits_map_with_expr() {
        let chunk = compile_snippet(
            r#"no strict 'vars';
            (map $_ + 1, (4, 5)) |> join ','"#,
        )
        .expect("compile");
        assert!(
            chunk.ops.iter().any(|o| matches!(o, Op::MapWithExpr(_))),
            "expected MapWithExpr, got {:?}",
            chunk.ops
        );
    }

    #[test]
    fn compile_hash_slice_deref_assign_emits_set_op() {
        let code = r#"no strict 'vars';
        my $h = { "a" => 1, "b" => 2 };
        my $r = $h;
        @$r{"a", "b"} = (10, 20);
        $r->{"a"} . "," . $r->{"b"};"#;
        let chunk = compile_snippet(code).expect("compile");
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::SetHashSliceDeref(n) if *n == 2)),
            "expected SetHashSliceDeref(2), got {:?}",
            chunk.ops
        );
    }

    #[test]
    fn compile_bare_array_assign_diamond_uses_readline_list() {
        let chunk = compile_snippet("@a = <>;").expect("compile");
        assert!(
            chunk.ops.iter().any(|o| matches!(
                o,
                Op::CallBuiltin(bid, 0) if *bid == BuiltinId::ReadLineList as u16
            )),
            "expected ReadLineList for bare @a = <>, got {:?}",
            chunk.ops
        );
    }

    #[test]
    fn compile_float_literal() {
        let chunk = compile_snippet("3.25;").expect("compile");
        assert!(chunk
            .ops
            .iter()
            .any(|o| matches!(o, Op::LoadFloat(f) if (*f - 3.25).abs() < 1e-9)));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_addition() {
        let chunk = compile_snippet("1 + 2;").expect("compile");
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::Add)));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_sub_mul_div_mod_pow() {
        for (src, op) in [
            ("10 - 3;", "Sub"),
            ("6 * 7;", "Mul"),
            ("8 / 2;", "Div"),
            ("9 % 4;", "Mod"),
            ("2 ** 8;", "Pow"),
        ] {
            let chunk = compile_snippet(src).expect(src);
            assert!(
                chunk.ops.iter().any(|o| std::mem::discriminant(o) == {
                    let dummy = match op {
                        "Sub" => Op::Sub,
                        "Mul" => Op::Mul,
                        "Div" => Op::Div,
                        "Mod" => Op::Mod,
                        "Pow" => Op::Pow,
                        _ => unreachable!(),
                    };
                    std::mem::discriminant(&dummy)
                }),
                "{} missing {:?}",
                src,
                op
            );
            assert_last_halt(&chunk);
        }
    }

    #[test]
    fn compile_string_literal_uses_constant_pool() {
        let chunk = compile_snippet(r#""hello";"#).expect("compile");
        assert!(chunk
            .constants
            .iter()
            .any(|c| c.as_str().as_deref() == Some("hello")));
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::LoadConst(_))));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_substitution_bind_emits_regex_subst() {
        let chunk = compile_snippet(r#"my $s = "aa"; $s =~ s/a/b/g;"#).expect("compile");
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::RegexSubst(_, _, _, _))),
            "expected RegexSubst in {:?}",
            chunk.ops
        );
        assert!(!chunk.lvalues.is_empty());
    }

    #[test]
    fn compile_chomp_emits_chomp_in_place() {
        let chunk = compile_snippet(r#"my $s = "x\n"; chomp $s;"#).expect("compile");
        assert!(
            chunk.ops.iter().any(|o| matches!(o, Op::ChompInPlace(_))),
            "expected ChompInPlace, got {:?}",
            chunk.ops
        );
    }

    #[test]
    fn compile_transliterate_bind_emits_regex_transliterate() {
        let chunk = compile_snippet(r#"my $u = "abc"; $u =~ tr/a-z/A-Z/;"#).expect("compile");
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::RegexTransliterate(_, _, _, _))),
            "expected RegexTransliterate in {:?}",
            chunk.ops
        );
        assert!(!chunk.lvalues.is_empty());
    }

    #[test]
    fn compile_negation() {
        let chunk = compile_snippet("-7;").expect("compile");
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::Negate)));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_my_scalar_declares() {
        let chunk = compile_snippet("my $x = 1;").expect("compile");
        assert!(chunk
            .ops
            .iter()
            .any(|o| matches!(o, Op::DeclareScalar(_) | Op::DeclareScalarSlot(_, _))));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_scalar_fetch_and_assign() {
        let chunk = compile_snippet("my $a = 1; $a + 0;").expect("compile");
        assert!(
            chunk
                .ops
                .iter()
                .filter(|o| matches!(
                    o,
                    Op::GetScalar(_) | Op::GetScalarPlain(_) | Op::GetScalarSlot(_)
                ))
                .count()
                >= 1
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_plain_scalar_read_emits_get_scalar_plain() {
        let chunk = compile_snippet("my $a = 1; $a + 0;").expect("compile");
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::GetScalarPlain(_) | Op::GetScalarSlot(_))),
            "expected GetScalarPlain or GetScalarSlot for non-special $a, ops={:?}",
            chunk.ops
        );
    }

    #[test]
    fn compile_sub_postfix_inc_emits_post_inc_slot() {
        let chunk = compile_snippet("fn foo { my $x = 0; $x++; return $x; }").expect("compile");
        assert!(
            chunk.ops.iter().any(|o| matches!(o, Op::PostIncSlot(_))),
            "expected PostIncSlot in compiled sub body, ops={:?}",
            chunk.ops
        );
    }

    #[test]
    fn compile_comparison_ops_numeric() {
        for src in [
            "1 < 2;", "1 > 2;", "1 <= 2;", "1 >= 2;", "1 == 2;", "1 != 2;",
        ] {
            let chunk = compile_snippet(src).expect(src);
            assert!(
                chunk.ops.iter().any(|o| {
                    matches!(
                        o,
                        Op::NumLt | Op::NumGt | Op::NumLe | Op::NumGe | Op::NumEq | Op::NumNe
                    )
                }),
                "{}",
                src
            );
            assert_last_halt(&chunk);
        }
    }

    #[test]
    fn compile_string_compare_ops() {
        for src in [
            r#"'a' lt 'b';"#,
            r#"'a' gt 'b';"#,
            r#"'a' le 'b';"#,
            r#"'a' ge 'b';"#,
        ] {
            let chunk = compile_snippet(src).expect(src);
            assert!(
                chunk
                    .ops
                    .iter()
                    .any(|o| matches!(o, Op::StrLt | Op::StrGt | Op::StrLe | Op::StrGe)),
                "{}",
                src
            );
            assert_last_halt(&chunk);
        }
    }

    #[test]
    fn compile_concat() {
        let chunk = compile_snippet(r#"'a' . 'b';"#).expect("compile");
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::Concat)));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_bitwise_ops() {
        let chunk = compile_snippet("1 & 2 | 3 ^ 4;").expect("compile");
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::BitAnd)));
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::BitOr)));
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::BitXor)));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_shift_right() {
        let chunk = compile_snippet("8 >> 1;").expect("compile");
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::Shr)));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_shift_left() {
        let chunk = compile_snippet("1 << 4;").expect("compile");
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::Shl)));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_log_not_and_bit_not() {
        let c1 = compile_snippet("!0;").expect("compile");
        assert!(c1.ops.iter().any(|o| matches!(o, Op::LogNot)));
        let c2 = compile_snippet("~0;").expect("compile");
        assert!(c2.ops.iter().any(|o| matches!(o, Op::BitNot)));
    }

    #[test]
    fn compile_sub_registers_name_and_entry() {
        let chunk = compile_snippet("fn foo { return 1; }").expect("compile");
        assert!(chunk.names.iter().any(|n| n == "foo"));
        assert!(chunk
            .sub_entries
            .iter()
            .any(|&(idx, ip, _)| chunk.names[idx as usize] == "foo" && ip > 0));
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::Halt)));
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::ReturnValue)));
    }

    #[test]
    fn compile_postinc_scalar() {
        let chunk = compile_snippet("my $n = 1; $n++;").expect("compile");
        assert!(chunk
            .ops
            .iter()
            .any(|o| matches!(o, Op::PostInc(_) | Op::PostIncSlot(_))));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_preinc_scalar() {
        let chunk = compile_snippet("my $n = 1; ++$n;").expect("compile");
        assert!(chunk
            .ops
            .iter()
            .any(|o| matches!(o, Op::PreInc(_) | Op::PreIncSlot(_))));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_if_expression_value() {
        let chunk = compile_snippet("if (1) { 2 } else { 3 }").expect("compile");
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::JumpIfFalse(_))));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_unless_expression_value() {
        let chunk = compile_snippet("unless (0) { 1 } else { 2 }").expect("compile");
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::JumpIfFalse(_))));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_array_declare_and_push() {
        let chunk = compile_snippet("my @a; push @a, 1;").expect("compile");
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::DeclareArray(_))));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_ternary() {
        let chunk = compile_snippet("1 ? 2 : 3;").expect("compile");
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::JumpIfFalse(_))));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_repeat_operator() {
        let chunk = compile_snippet(r#"'ab' x 3;"#).expect("compile");
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::StringRepeat)));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_range_to_array() {
        let chunk = compile_snippet("my @a = (1..3);").expect("compile");
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::Range)));
        assert_last_halt(&chunk);
    }

    /// Scalar `..` / `...` in a boolean condition must be the flip-flop (`$.`), not a list range.
    #[test]
    fn compile_print_if_uses_scalar_flipflop_not_range_list() {
        let chunk = compile_snippet("print if 1..2;").expect("compile");
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::ScalarFlipFlop(_, 0))),
            "expected ScalarFlipFlop in bytecode, got:\n{}",
            chunk.disassemble()
        );
        assert!(
            !chunk.ops.iter().any(|o| matches!(o, Op::Range)),
            "did not expect list Range op in scalar if-condition:\n{}",
            chunk.disassemble()
        );
    }

    #[test]
    fn compile_print_if_three_dot_scalar_flipflop_sets_exclusive_flag() {
        let chunk = compile_snippet("print if 1...2;").expect("compile");
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::ScalarFlipFlop(_, 1))),
            "expected ScalarFlipFlop(..., exclusive=1), got:\n{}",
            chunk.disassemble()
        );
    }

    #[test]
    fn compile_regex_flipflop_two_dot_emits_regex_flipflop_op() {
        let chunk = compile_snippet(r#"print if /a/../b/;"#).expect("compile");
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::RegexFlipFlop(_, 0, _, _, _, _))),
            "expected RegexFlipFlop(.., exclusive=0), got:\n{}",
            chunk.disassemble()
        );
        assert!(
            !chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::ScalarFlipFlop(_, _))),
            "regex flip-flop must not use ScalarFlipFlop:\n{}",
            chunk.disassemble()
        );
    }

    #[test]
    fn compile_regex_flipflop_three_dot_sets_exclusive_flag() {
        let chunk = compile_snippet(r#"print if /a/.../b/;"#).expect("compile");
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::RegexFlipFlop(_, 1, _, _, _, _))),
            "expected RegexFlipFlop(..., exclusive=1), got:\n{}",
            chunk.disassemble()
        );
    }

    #[test]
    fn compile_regex_eof_flipflop_emits_regex_eof_flipflop_op() {
        let chunk = compile_snippet(r#"print if /a/..eof;"#).expect("compile");
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::RegexEofFlipFlop(_, 0, _, _))),
            "expected RegexEofFlipFlop(.., exclusive=0), got:\n{}",
            chunk.disassemble()
        );
        assert!(
            !chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::ScalarFlipFlop(_, _))),
            "regex/eof flip-flop must not use ScalarFlipFlop:\n{}",
            chunk.disassemble()
        );
    }

    #[test]
    fn compile_regex_eof_flipflop_three_dot_sets_exclusive_flag() {
        let chunk = compile_snippet(r#"print if /a/...eof;"#).expect("compile");
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::RegexEofFlipFlop(_, 1, _, _))),
            "expected RegexEofFlipFlop(..., exclusive=1), got:\n{}",
            chunk.disassemble()
        );
    }

    #[test]
    fn compile_regex_flipflop_compound_rhs_emits_regex_flip_flop_expr_rhs() {
        let chunk = compile_snippet(r#"print if /a/...(/b/ or /c/);"#).expect("compile");
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::RegexFlipFlopExprRhs(_, _, _, _, _))),
            "expected RegexFlipFlopExprRhs for compound RHS, got:\n{}",
            chunk.disassemble()
        );
        assert!(
            !chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::ScalarFlipFlop(_, _))),
            "compound regex flip-flop must not use ScalarFlipFlop:\n{}",
            chunk.disassemble()
        );
    }

    #[test]
    fn compile_print_statement() {
        let chunk = compile_snippet("print 1;").expect("compile");
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::Print(_, _))));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_defined_builtin() {
        let chunk = compile_snippet("defined 1;").expect("compile");
        assert!(chunk
            .ops
            .iter()
            .any(|o| matches!(o, Op::CallBuiltin(id, _) if *id == BuiltinId::Defined as u16)));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_length_builtin() {
        let chunk = compile_snippet("length 'abc';").expect("compile");
        assert!(chunk
            .ops
            .iter()
            .any(|o| matches!(o, Op::CallBuiltin(id, _) if *id == BuiltinId::Length as u16)));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_complex_expr_parentheses() {
        let chunk = compile_snippet("(1 + 2) * (3 + 4);").expect("compile");
        assert!(chunk.ops.iter().filter(|o| matches!(o, Op::Add)).count() >= 2);
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::Mul)));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_undef_literal() {
        let chunk = compile_snippet("undef;").expect("compile");
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::LoadUndef)));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_empty_statement_semicolons() {
        let chunk = compile_snippet(";;;").expect("compile");
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_array_elem_preinc_uses_rot_and_set_elem() {
        let chunk = compile_snippet("my @a; $a[0] = 0; ++$a[0];").expect("compile");
        assert!(
            chunk.ops.iter().any(|o| matches!(o, Op::Rot)),
            "expected Rot in {:?}",
            chunk.ops
        );
        assert!(
            chunk.ops.iter().any(|o| matches!(o, Op::SetArrayElem(_))),
            "expected SetArrayElem in {:?}",
            chunk.ops
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_hash_elem_compound_assign_uses_rot() {
        let chunk = compile_snippet("my %h; $h{0} = 1; $h{0} += 2;").expect("compile");
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::Rot)));
        assert!(
            chunk.ops.iter().any(|o| matches!(o, Op::SetHashElem(_))),
            "expected SetHashElem"
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_postfix_inc_array_elem_emits_rot() {
        let chunk = compile_snippet("my @a; $a[1] = 5; $a[1]++;").expect("compile");
        assert!(chunk.ops.iter().any(|o| matches!(o, Op::Rot)));
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_tie_stmt_emits_op_tie() {
        let chunk = compile_snippet("tie %h, 'Pkg';").expect("compile");
        assert!(
            chunk.ops.iter().any(|o| matches!(o, Op::Tie { .. })),
            "expected Op::Tie in {:?}",
            chunk.ops
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_format_decl_emits_format_decl_op() {
        let chunk = compile_snippet(
            r#"
format FMT =
literal line
.
1;
"#,
        )
        .expect("compile");
        assert!(
            chunk.ops.iter().any(|o| matches!(o, Op::FormatDecl(0))),
            "expected Op::FormatDecl(0), got {:?}",
            chunk.ops
        );
        assert_eq!(chunk.format_decls.len(), 1);
        assert_eq!(chunk.format_decls[0].0, "FMT");
        assert_eq!(chunk.format_decls[0].1, vec!["literal line".to_string()]);
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_interpolated_string_scalar_only_emits_empty_prefix_and_concat() {
        let chunk = compile_snippet(r#"no strict 'vars'; my $x = 1; "$x";"#).expect("compile");
        let empty_idx = chunk
            .constants
            .iter()
            .position(|c| c.as_str().is_some_and(|s| s.is_empty()))
            .expect("empty string in pool") as u16;
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::LoadConst(i) if *i == empty_idx)),
            "expected LoadConst(\"\"), ops={:?}",
            chunk.ops
        );
        assert!(
            chunk.ops.iter().any(|o| matches!(o, Op::Concat)),
            "expected Op::Concat for qq with only a scalar part, ops={:?}",
            chunk.ops
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_interpolated_string_array_only_emits_stringify_and_concat() {
        let chunk = compile_snippet(r#"no strict 'vars'; my @a = (1, 2); "@a";"#).expect("compile");
        let empty_idx = chunk
            .constants
            .iter()
            .position(|c| c.as_str().is_some_and(|s| s.is_empty()))
            .expect("empty string in pool") as u16;
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::LoadConst(i) if *i == empty_idx)),
            "expected LoadConst(\"\"), ops={:?}",
            chunk.ops
        );
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::ArrayStringifyListSep)),
            "expected ArrayStringifyListSep for array var in qq, ops={:?}",
            chunk.ops
        );
        assert!(
            chunk.ops.iter().any(|o| matches!(o, Op::Concat)),
            "expected Op::Concat after array stringify, ops={:?}",
            chunk.ops
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_interpolated_string_hash_element_only_emits_empty_prefix_and_concat() {
        let chunk =
            compile_snippet(r#"no strict 'vars'; my %h = (k => 1); "$h{k}";"#).expect("compile");
        let empty_idx = chunk
            .constants
            .iter()
            .position(|c| c.as_str().is_some_and(|s| s.is_empty()))
            .expect("empty string in pool") as u16;
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::LoadConst(i) if *i == empty_idx)),
            "expected LoadConst(\"\"), ops={:?}",
            chunk.ops
        );
        assert!(
            chunk.ops.iter().any(|o| matches!(o, Op::Concat)),
            "expected Op::Concat for qq with only an expr part, ops={:?}",
            chunk.ops
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_interpolated_string_leading_literal_has_no_empty_string_prefix() {
        let chunk = compile_snippet(r#"no strict 'vars'; my $x = 1; "a$x";"#).expect("compile");
        assert!(
            !chunk
                .constants
                .iter()
                .any(|c| c.as_str().is_some_and(|s| s.is_empty())),
            "literal-first qq must not intern \"\" (only non-literal first parts need it), ops={:?}",
            chunk.ops
        );
        assert!(
            chunk.ops.iter().any(|o| matches!(o, Op::Concat)),
            "expected Op::Concat after literal + scalar, ops={:?}",
            chunk.ops
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_interpolated_string_two_scalars_empty_prefix_and_two_concats() {
        let chunk =
            compile_snippet(r#"no strict 'vars'; my $a = 1; my $b = 2; "$a$b";"#).expect("compile");
        let empty_idx = chunk
            .constants
            .iter()
            .position(|c| c.as_str().is_some_and(|s| s.is_empty()))
            .expect("empty string in pool") as u16;
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::LoadConst(i) if *i == empty_idx)),
            "expected LoadConst(\"\") before first scalar qq part, ops={:?}",
            chunk.ops
        );
        let n_concat = chunk.ops.iter().filter(|o| matches!(o, Op::Concat)).count();
        assert!(
            n_concat >= 2,
            "expected at least two Op::Concat for two scalar qq parts, got {} in {:?}",
            n_concat,
            chunk.ops
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_interpolated_string_literal_then_two_scalars_has_no_empty_prefix() {
        let chunk = compile_snippet(r#"no strict 'vars'; my $x = 7; my $y = 8; "p$x$y";"#)
            .expect("compile");
        assert!(
            !chunk
                .constants
                .iter()
                .any(|c| c.as_str().is_some_and(|s| s.is_empty())),
            "literal-first qq must not intern empty string, ops={:?}",
            chunk.ops
        );
        let n_concat = chunk.ops.iter().filter(|o| matches!(o, Op::Concat)).count();
        assert!(
            n_concat >= 2,
            "expected two Concats for literal + two scalars, got {} in {:?}",
            n_concat,
            chunk.ops
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_interpolated_string_braced_scalar_trailing_literal_emits_concats() {
        let chunk = compile_snippet(r#"no strict 'vars'; my $u = 1; "a${u}z";"#).expect("compile");
        let n_concat = chunk.ops.iter().filter(|o| matches!(o, Op::Concat)).count();
        assert!(
            n_concat >= 2,
            "expected braced scalar + trailing literal to use multiple Concats, got {} in {:?}",
            n_concat,
            chunk.ops
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_interpolated_string_braced_scalar_sandwiched_emits_concats() {
        let chunk = compile_snippet(r#"no strict 'vars'; my $u = 1; "L${u}R";"#).expect("compile");
        let n_concat = chunk.ops.iter().filter(|o| matches!(o, Op::Concat)).count();
        assert!(
            n_concat >= 2,
            "expected leading literal + braced scalar + trailing literal to use multiple Concats, got {} in {:?}",
            n_concat,
            chunk.ops
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_interpolated_string_mixed_braced_and_plain_scalars_emits_concats() {
        let chunk = compile_snippet(r#"no strict 'vars'; my $x = 1; my $y = 2; "a${x}b$y";"#)
            .expect("compile");
        let n_concat = chunk.ops.iter().filter(|o| matches!(o, Op::Concat)).count();
        assert!(
            n_concat >= 3,
            "expected literal/braced/plain qq mix to use at least three Concats, got {} in {:?}",
            n_concat,
            chunk.ops
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_use_overload_emits_use_overload_op() {
        let chunk = compile_snippet(r#"use overload '""' => 'as_string';"#).expect("compile");
        assert!(
            chunk.ops.iter().any(|o| matches!(o, Op::UseOverload(0))),
            "expected Op::UseOverload(0), got {:?}",
            chunk.ops
        );
        assert_eq!(chunk.use_overload_entries.len(), 1);
        // Perl `'""'` is a single-quoted string whose contents are two `"` characters — the
        // overload table key for stringify (see [`Interpreter::overload_stringify_method`]).
        let stringify_key: String = ['"', '"'].iter().collect();
        assert_eq!(
            chunk.use_overload_entries[0],
            vec![(stringify_key, "as_string".to_string())]
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_use_overload_empty_list_emits_use_overload_with_no_pairs() {
        let chunk = compile_snippet(r#"use overload ();"#).expect("compile");
        assert!(
            chunk.ops.iter().any(|o| matches!(o, Op::UseOverload(0))),
            "expected Op::UseOverload(0), got {:?}",
            chunk.ops
        );
        assert_eq!(chunk.use_overload_entries.len(), 1);
        assert!(chunk.use_overload_entries[0].is_empty());
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_use_overload_multiple_pairs_single_op() {
        let chunk =
            compile_snippet(r#"use overload '+' => 'p_add', '-' => 'p_sub';"#).expect("compile");
        assert!(
            chunk.ops.iter().any(|o| matches!(o, Op::UseOverload(0))),
            "expected Op::UseOverload(0), got {:?}",
            chunk.ops
        );
        assert_eq!(chunk.use_overload_entries.len(), 1);
        assert_eq!(
            chunk.use_overload_entries[0],
            vec![
                ("+".to_string(), "p_add".to_string()),
                ("-".to_string(), "p_sub".to_string()),
            ]
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_open_my_fh_emits_declare_open_set() {
        let chunk = compile_snippet(r#"open my $fh, "<", "/dev/null";"#).expect("compile");
        assert!(
            chunk.ops.iter().any(|o| matches!(
                o,
                Op::CallBuiltin(b, 3) if *b == BuiltinId::Open as u16
            )),
            "expected Open builtin 3-arg, got {:?}",
            chunk.ops
        );
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::SetScalarKeepPlain(_))),
            "expected SetScalarKeepPlain after open"
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_local_hash_element_emits_local_declare_hash_element() {
        let chunk = compile_snippet(r#"local $SIG{__WARN__} = 0;"#).expect("compile");
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::LocalDeclareHashElement(_))),
            "expected LocalDeclareHashElement in {:?}",
            chunk.ops
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_local_array_element_emits_local_declare_array_element() {
        let chunk = compile_snippet(r#"local $a[2] = 9;"#).expect("compile");
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::LocalDeclareArrayElement(_))),
            "expected LocalDeclareArrayElement in {:?}",
            chunk.ops
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_local_typeglob_emits_local_declare_typeglob() {
        let chunk = compile_snippet(r#"local *STDOUT;"#).expect("compile");
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::LocalDeclareTypeglob(_, None))),
            "expected LocalDeclareTypeglob(_, None) in {:?}",
            chunk.ops
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_local_typeglob_alias_emits_local_declare_typeglob_some_rhs() {
        let chunk = compile_snippet(r#"local *FOO = *STDOUT;"#).expect("compile");
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::LocalDeclareTypeglob(_, Some(_)))),
            "expected LocalDeclareTypeglob with rhs in {:?}",
            chunk.ops
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_local_braced_typeglob_emits_local_declare_typeglob_dynamic() {
        let chunk = compile_snippet(r#"no strict 'refs'; my $g = "STDOUT"; local *{ $g };"#)
            .expect("compile");
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::LocalDeclareTypeglobDynamic(None))),
            "expected LocalDeclareTypeglobDynamic(None) in {:?}",
            chunk.ops
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_local_star_deref_typeglob_emits_local_declare_typeglob_dynamic() {
        let chunk =
            compile_snippet(r#"no strict 'refs'; my $g = "STDOUT"; local *$g;"#).expect("compile");
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::LocalDeclareTypeglobDynamic(None))),
            "expected LocalDeclareTypeglobDynamic(None) for local *scalar glob in {:?}",
            chunk.ops
        );
        assert_last_halt(&chunk);
    }

    #[test]
    fn compile_braced_glob_assign_to_named_glob_emits_copy_dynamic_lhs() {
        // `*{EXPR} = *FOO` — dynamic lhs name + static rhs glob → `CopyTypeglobSlotsDynamicLhs`.
        let chunk = compile_snippet(r#"no strict 'refs'; my $n = "x"; *{ $n } = *STDOUT;"#)
            .expect("compile");
        assert!(
            chunk
                .ops
                .iter()
                .any(|o| matches!(o, Op::CopyTypeglobSlotsDynamicLhs(_))),
            "expected CopyTypeglobSlotsDynamicLhs in {:?}",
            chunk.ops
        );
        assert_last_halt(&chunk);
    }
}