shape-vm 0.3.2

//! Expression lowering: AST expressions -> MIR temporaries and places.
//!
//! The central function is `lower_expr_to_temp`, which dispatches on
//! `Expr` variants and produces a `SlotId` holding the result. Complex
//! expression forms (conditionals, blocks, match, loops) build their own
//! control-flow subgraphs.

use super::helpers::*;
use super::stmt::{lower_statement, lower_statements, lower_var_decl, StatementSpan};
use super::MirBuilder;
use super::immutable_binding_metadata;
use crate::mir::types::*;
use shape_ast::ast::{self, Expr, Literal, Span, Spanned, Statement};
use shape_ast::interpolation::{parse_interpolation_with_mode, InterpolationPart};
use shape_runtime::closure::EnvironmentAnalyzer;

// ---------------------------------------------------------------------------
// Place resolution
// ---------------------------------------------------------------------------

/// Try to resolve an expression as a MIR place (lvalue).
pub(super) fn lower_expr_to_place(builder: &mut MirBuilder, expr: &Expr) -> Option<Place> {
    match expr {
        Expr::Identifier(name, _) | Expr::PatternRef(name, _) => {
            builder.lookup_local(name).map(Place::Local)
        }
        Expr::PropertyAccess {
            object, property, ..
        } => {
            let base = lower_expr_to_place(builder, object)?;
            Some(Place::Field(Box::new(base), builder.field_idx(property)))
        }
        Expr::IndexAccess {
            object,
            index,
            end_index,
            ..
        } => {
            if end_index.is_some() {
                return None;
            }
            let base = lower_expr_to_place(builder, object)?;
            let index_operand = lower_expr_to_operand(builder, index, false);
            Some(Place::Index(Box::new(base), Box::new(index_operand)))
        }
        _ => None,
    }
}

// ---------------------------------------------------------------------------
// Int-literal width inference (ADR-006 §2.7.5 stamp-at-compile-time)
// ---------------------------------------------------------------------------

/// If `expr` is a bare integer literal, return its value. `Literal::UInt`
/// is always non-negative. `Literal::TypedInt` is excluded — an explicitly
/// suffixed literal has a programmer-chosen width and does not adapt.
/// Mirrors the bytecode compiler's `bare_int_literal_value`
/// (`compiler/expressions/binary_ops.rs`).
fn bare_int_literal_value(expr: &Expr) -> Option<i128> {
    match expr {
        Expr::Literal(Literal::Int(v), _) => Some(*v as i128),
        Expr::Literal(Literal::UInt(v), _) => Some(*v as i128),
        _ => None,
    }
}

/// Returns `true` when an expression is statically known to be `u64`-typed
/// at MIR-lowering time:
///
/// - a `u64` literal (`Literal::UInt`),
/// - an identifier whose binding slot carries the declared scalar
///   `ConcreteType::U64` recorded by `lower_var_decl`'s
///   `record_local_declared_scalar_type`,
/// - an arithmetic `BinaryOp` whose own operands resolve (recursively) to
///   `u64` — `a / 2` on `a: u64` is itself a `u64` expression, so
///   `(a / 2) == 5` lowers the `5` as a direct constant too.
///
/// This is the MIR-side analogue of the bytecode compiler's
/// `NumericType::IntWidth(U64)` slot-tracker hint.
///
/// Scoped to `u64` — the only integer width where signed and unsigned div/
/// mod/compare genuinely diverge for the JIT codegen. The narrow widths
/// (`i8`/.../`u32`) are handled by the bytecode-compiler half of this fix
/// (`promote_int_literal_to_width_sibling`); their JIT path
/// (`compile_binop_narrow_int`) is checkpoint-(c) territory and is left
/// to fall back to the interpreter on a hoisted-literal operand, exactly
/// as before this change — VM and JIT stay in agreement because both run
/// the (now-fixed) bytecode interpreter for that case.
fn expr_is_u64_typed(builder: &MirBuilder, expr: &Expr) -> bool {
    use shape_ast::ast::BinaryOp;
    use shape_value::v2::ConcreteType;
    match expr {
        Expr::Literal(Literal::UInt(_), _) => true,
        Expr::Identifier(name, _) => builder
            .lookup_local(name)
            .and_then(|slot| builder.lookup_local_declared_scalar_type(slot))
            .is_some_and(|ct| matches!(ct, ConcreteType::U64)),
        Expr::BinaryOp { left, op, right, .. }
            if matches!(
                op,
                BinaryOp::Add
                    | BinaryOp::Sub
                    | BinaryOp::Mul
                    | BinaryOp::Div
                    | BinaryOp::Mod
            ) =>
        {
            expr_is_u64_typed(builder, left) || expr_is_u64_typed(builder, right)
        }
        _ => false,
    }
}

/// ADR-006 §2.7.5 stamp-at-compile-time — u64-literal kind inference (MIR
/// producer half; the bytecode-compiler half lives in
/// `compiler/expressions/binary_ops.rs::promote_int_literal_to_width_sibling`).
///
/// When a binary op pairs a `u64`-typed operand with a bare integer
/// literal, lower the literal directly as `Operand::Constant(MirConstant::
/// Int(_))` rather than through `lower_expr_to_operand` (which hoists it
/// into a `Copy(Local)` temp). The JIT's `uint64_binop_site` classifier
/// explicitly recognizes a direct `Operand::Constant(MirConstant::Int(_))`
/// sibling as a width-polymorphic literal that adopts the `u64` width —
/// `(UInt64, Int64-literal)` → unsigned `udiv`/`urem`/`Unsigned*` compares.
/// A hoisted `Copy(Local)` temp is NOT recognized (its slot kind is the
/// width-blind `Int64`), so the binop falls into the kind-untyped
/// surface-and-stop arm.
///
/// Returns `Some(operand)` when `expr` is a bare integer literal; `None`
/// for any other expression (the caller falls back to
/// `lower_expr_to_operand`).
fn lower_int_literal_as_direct_constant(expr: &Expr) -> Option<Operand> {
    bare_int_literal_value(expr).map(|_| match expr {
        Expr::Literal(Literal::Int(v), _) => Operand::Constant(MirConstant::Int(*v)),
        Expr::Literal(Literal::UInt(v), _) => Operand::Constant(MirConstant::Int(*v as i64)),
        _ => unreachable!("bare_int_literal_value gated to Int/UInt"),
    })
}

// ---------------------------------------------------------------------------
// Operand lowering
// ---------------------------------------------------------------------------

pub(super) fn lower_expr_to_operand(
    builder: &mut MirBuilder,
    expr: &Expr,
    prefer_move: bool,
) -> Operand {
    if let Some(place) = lower_expr_to_place(builder, expr) {
        let operand = if prefer_move {
            Operand::Move(place)
        } else {
            Operand::Copy(place)
        };
        builder.record_task_boundary_operand(operand.clone());
        operand
    } else {
        let slot = lower_expr_to_temp(builder, expr);
        let place = Place::Local(slot);
        let operand = if prefer_move {
            Operand::Move(place)
        } else {
            Operand::Copy(place)
        };
        builder.record_task_boundary_operand(operand.clone());
        operand
    }
}

pub(super) fn lower_expr_to_explicit_move_operand(
    builder: &mut MirBuilder,
    expr: &Expr,
) -> Operand {
    if let Some(place) = lower_expr_to_place(builder, expr) {
        Operand::MoveExplicit(place)
    } else {
        let slot = lower_expr_to_temp(builder, expr);
        Operand::MoveExplicit(Place::Local(slot))
    }
}

/// ADR-006 §2.7.27 / W17-mutation-writeback: emit a receiver write-back
/// after a mutating method call so the JIT (which compiles from MIR) sees
/// the new Arc in the receiver slot on subsequent reads. Mirrors the
/// bytecode compiler's `Dup; StoreLocal recv` pattern at
/// `compiler/expressions/function_calls.rs:2356` — there the result also
/// stays on the stack as the call's expression value; here the call's
/// destination temp is already populated, so the writeback is the
/// secondary `Assign(receiver_slot, Use(Move(temp)))`.
///
/// Gate: receiver must be `Expr::Identifier` resolving to a slot tracked
/// in `mut_self_container_locals`, AND `method` must be in that kind's
/// `MUT_SELF_*` set. Interior-mutability primitives (Mutex / Atomic /
/// Lazy / Channel) are not registered, so this returns without emitting.
pub(super) fn emit_mut_self_writeback_if_needed(
    builder: &mut MirBuilder,
    receiver: &Expr,
    method: &str,
    temp: SlotId,
    span: Span,
) {
    let Expr::Identifier(name, _) = receiver else {
        return;
    };
    let Some(slot) = builder.lookup_local(name) else {
        return;
    };
    let Some(kind) = builder.lookup_mut_self_container_local(slot) else {
        return;
    };
    if !kind.is_mut_self_method(method) {
        return;
    }
    builder.push_stmt(
        StatementKind::Assign(
            Place::Local(slot),
            Rvalue::Use(Operand::Move(Place::Local(temp))),
        ),
        span,
    );
}

pub(super) fn lower_expr_as_moved_operand(builder: &mut MirBuilder, expr: &Expr) -> Operand {
    if let Some(place) = lower_expr_to_place(builder, expr) {
        // Use Copy for named variables (identifiers, property accesses, index accesses)
        // because the variable may be used again after this call. Only temporaries
        // (generated by lower_expr_to_temp in the else branch) are safe to Move
        // since they are single-use.
        let operand = Operand::Copy(place);
        builder.record_task_boundary_operand(operand.clone());
        operand
    } else {
        let operand = Operand::Move(Place::Local(lower_expr_to_temp(builder, expr)));
        builder.record_task_boundary_operand(operand.clone());
        operand
    }
}

pub(super) fn lower_exprs_to_aggregate<'a>(
    builder: &mut MirBuilder,
    temp: SlotId,
    exprs: impl IntoIterator<Item = &'a Expr>,
    span: Span,
) {
    let operands = exprs
        .into_iter()
        .map(|expr| lower_expr_as_moved_operand(builder, expr))
        .collect();
    builder.push_stmt(
        StatementKind::Assign(Place::Local(temp), Rvalue::Aggregate(operands)),
        span,
    );
}

pub(super) fn lower_assign_target_place(
    builder: &mut MirBuilder,
    target: &Expr,
) -> Option<Place> {
    match target {
        Expr::Identifier(name, _) => builder.lookup_local(name).map(Place::Local),
        Expr::PropertyAccess { .. } | Expr::IndexAccess { .. } => {
            lower_expr_to_place(builder, target)
        }
        _ => None,
    }
}

// ---------------------------------------------------------------------------
// Closure / function expression helpers
// ---------------------------------------------------------------------------

fn collect_function_expr_capture_operands(
    builder: &MirBuilder,
    params: &[ast::FunctionParameter],
    body: &[Statement],
) -> Vec<Operand> {
    let proto_def = ast::FunctionDef {
        name: "__mir_closure".to_string(),
        name_span: Span::DUMMY,
        declaring_module_path: None,
        doc_comment: None,
        type_params: None,
        params: params.to_vec(),
        return_type: None,
        body: body.to_vec(),
        annotations: vec![],
        where_clause: None,
        is_async: false,
        is_comptime: false,
    };

    let mut captured_vars =
        EnvironmentAnalyzer::analyze_function(&proto_def, &builder.visible_named_locals());
    captured_vars.sort();
    captured_vars.dedup();

    let mut operands = Vec::new();
    for name in captured_vars {
        let Some(slot) = builder.lookup_local(&name) else {
            continue;
        };
        let operand = Operand::Copy(Place::Local(slot));
        if !operands.contains(&operand) {
            operands.push(operand);
        }
    }
    operands
}

fn lower_function_expr(
    builder: &mut MirBuilder,
    params: &[ast::FunctionParameter],
    body: &[Statement],
    temp: SlotId,
    span: Span,
) {
    let captures = collect_function_expr_capture_operands(builder, params, body);
    emit_container_store_if_needed(builder, ContainerStoreKind::Closure, temp, captures, span);
    // Emit ClosurePlaceholder instead of None — patched to Function(name) after bytecode compilation
    assign_closure_placeholder(builder, temp, span);
}

// ---------------------------------------------------------------------------
// Specific expression lowering functions
// ---------------------------------------------------------------------------

fn lower_array_expr(builder: &mut MirBuilder, elements: &[Expr], temp: SlotId, span: Span) {
    let operands: Vec<_> = elements
        .iter()
        .map(|expr| lower_expr_as_moved_operand(builder, expr))
        .collect();
    builder.push_stmt(
        StatementKind::Assign(Place::Local(temp), Rvalue::Aggregate(operands.clone())),
        span,
    );
    emit_container_store_if_needed(builder, ContainerStoreKind::Array, temp, operands, span);
}

fn lower_window_function_operands(
    builder: &mut MirBuilder,
    func: &ast::windows::WindowFunction,
    operands: &mut Vec<Operand>,
) {
    use ast::windows::WindowFunction;
    match func {
        WindowFunction::Lag { expr, default, .. }
        | WindowFunction::Lead { expr, default, .. } => {
            operands.push(lower_expr_as_moved_operand(builder, expr));
            if let Some(d) = default {
                operands.push(lower_expr_as_moved_operand(builder, d));
            }
        }
        WindowFunction::FirstValue(e)
        | WindowFunction::LastValue(e)
        | WindowFunction::Sum(e)
        | WindowFunction::Avg(e)
        | WindowFunction::Min(e)
        | WindowFunction::Max(e) => {
            operands.push(lower_expr_as_moved_operand(builder, e));
        }
        WindowFunction::NthValue(e, _) => {
            operands.push(lower_expr_as_moved_operand(builder, e));
        }
        WindowFunction::Count(Some(e)) => {
            operands.push(lower_expr_as_moved_operand(builder, e));
        }
        WindowFunction::RowNumber
        | WindowFunction::Rank
        | WindowFunction::DenseRank
        | WindowFunction::Ntile(_)
        | WindowFunction::Count(None) => {}
    }
}

fn lower_await_expr(builder: &mut MirBuilder, inner: &Expr, temp: SlotId, span: Span) {
    let operand = lower_expr_to_operand(builder, inner, true);
    builder.push_stmt(
        StatementKind::Assign(Place::Local(temp), Rvalue::Use(operand)),
        span,
    );
}

fn lower_async_scope_expr(builder: &mut MirBuilder, inner: &Expr, temp: SlotId, span: Span) {
    builder.async_scope_depth += 1;
    let inner_slot = lower_expr_to_temp(builder, inner);
    builder.async_scope_depth -= 1;
    assign_copy_from_slot(builder, temp, inner_slot, span);
}

fn lower_async_let_expr(
    builder: &mut MirBuilder,
    async_let: &ast::AsyncLetExpr,
    temp: SlotId,
    span: Span,
) {
    builder.push_task_boundary_capture_scope();
    let _ = lower_expr_to_operand(builder, &async_let.expr, true);
    let captures = builder.pop_task_boundary_capture_scope();
    emit_task_boundary_if_needed(builder, captures, async_let.span);

    // async let bindings are immutable — the future must not be overwritten.
    let binding_metadata = immutable_binding_metadata(async_let.span, true, false);
    let future_slot = builder.alloc_local_binding(
        async_let.name.clone(),
        LocalTypeInfo::Unknown,
        binding_metadata,
    );
    let init_point = builder.push_stmt(
        StatementKind::Assign(
            Place::Local(future_slot),
            Rvalue::Use(Operand::Constant(crate::mir::types::MirConstant::None)),
        ),
        async_let.span,
    );
    builder.record_binding_initialization(future_slot, init_point);
    assign_copy_from_slot(builder, temp, future_slot, span);
}

fn lower_join_expr(
    builder: &mut MirBuilder,
    join_expr: &ast::JoinExpr,
    temp: SlotId,
    span: Span,
) {
    if join_expr.branches.is_empty() {
        assign_none(builder, temp, span);
        return;
    }

    // `join all/race/any/settle` is structured concurrency — all branches are
    // joined before the parent scope exits.
    builder.async_scope_depth += 1;
    let mut branch_operands = Vec::with_capacity(join_expr.branches.len());
    for branch in &join_expr.branches {
        builder.push_task_boundary_capture_scope();
        for annotation in &branch.annotations {
            for arg in &annotation.args {
                let _ = lower_expr_to_temp(builder, arg);
            }
        }
        let branch_operand = lower_expr_to_operand(builder, &branch.expr, true);
        let captures = builder.pop_task_boundary_capture_scope();
        emit_task_boundary_if_needed(builder, captures, branch.expr.span());
        branch_operands.push(branch_operand);
    }
    builder.async_scope_depth -= 1;

    builder.push_stmt(
        StatementKind::Assign(Place::Local(temp), Rvalue::Aggregate(branch_operands)),
        join_expr.span,
    );
}

fn lower_list_comprehension_expr(
    builder: &mut MirBuilder,
    comp: &ast::ListComprehension,
    temp: SlotId,
    span: Span,
) {
    builder.push_scope();
    for clause in &comp.clauses {
        // W11-followup-comprehension-kindtracker (2026-05-18):
        // mirror `lower_for_expr`'s `Expr::Range { start: Some, end: Some }`
        // counter-binding shape for the comprehension iteration variable.
        // The bytecode compiler's `compile_comprehension_clauses` runs
        // `try_begin_range_counter_loop` (`compiler/loops.rs:34`), which
        // declares the user-visible loop variable AS the counter slot
        // and initializes it from `compile_expr(start_expr)` (an int
        // literal in the common case). The MIR side previously evaluated
        // start/end into discarded temps (W11-jit-new-array's narrow
        // Range carrier deletion, 836a77f5) and then bound the
        // iteration variable via `lower_destructure_bindings_from_place`
        // against an `assign_none` element slot — that erased the
        // iteration variable's `NativeKind` (None constant → kind None)
        // and downstream `x * x` in the comprehension body reached the
        // JIT with kind-untyped operands, surfacing at
        // `compile_binop_dynamic_arith` (`crates/shape-jit/src/mir_compiler/
        // rvalues.rs:757`).
        //
        // The new shape (when the pattern is a simple identifier and the
        // iterable is a closed `Expr::Range`): allocate the iteration
        // variable as a named local and seed it via `Use(Copy(start_slot))`.
        // The JIT's `infer_slot_kinds_with_concrete`
        // (`crates/shape-jit/src/mir_compiler/types.rs:289`) forward
        // pass already propagates `Int64` from the start expression's
        // literal-stamped slot through the `Use(Copy(_))` chain to the
        // iteration variable, satisfying ADR-006 §2.7.5 stamp-at-
        // compile-time for the `x * x` operand binop. No runtime tag
        // dispatch is reintroduced; the kind source IS the start
        // expression's literal.
        //
        // For non-identifier patterns (tuple / object destructure of a
        // range — currently unreachable since ranges yield scalars, but
        // future-proofing) or non-Range iterables, fall through to the
        // existing path: W11-jit-new-array's Range carrier deletion is
        // preserved (no `Aggregate` wrapper) and the broader iterable-
        // element-kind threading remains a follow-up scope (generic
        // `Iterable<T>` element kind not statically known at the MIR
        // emission site without a deeper signature classifier).
        let iv_counter_simple_range = match (
            clause.pattern.as_identifier(),
            clause.iterable.as_ref(),
        ) {
            (
                Some(iv_name),
                Expr::Range {
                    start: Some(start_expr),
                    end: Some(end_expr),
                    ..
                },
            ) => Some((iv_name.to_string(), start_expr, end_expr)),
            _ => None,
        };

        if let Some((iv_name, start_expr, end_expr)) = iv_counter_simple_range {
            let start_slot = lower_expr_to_temp(builder, start_expr);
            let _ = lower_expr_to_temp(builder, end_expr);
            // Allocate the user-visible iteration variable as a named
            // local (mirror `lower_for_expr` counter-binding) and seed
            // its value from `start_slot`. The forward kind-inference
            // pass propagates `Int64` (from the int literal) through
            // this `Use(Copy(start_slot))` write.
            let iv_slot = builder.alloc_local(iv_name, LocalTypeInfo::Copy);
            assign_copy_from_slot(builder, iv_slot, start_slot, clause.iterable.span());
            if let Some(filter) = &clause.filter {
                let _ = lower_expr_to_temp(builder, filter);
            }
        } else {
            // Fallback path — preserves W11-jit-new-array Range carrier
            // deletion when the iterable is a closed range (no Aggregate
            // wrapper) for borrow-tracker compatibility. For non-
            // identifier patterns the iteration-variable kind is not
            // threaded — comprehension body arith on the iteration
            // variable will surface at `compile_binop_dynamic_arith`
            // (the W11-followup-comprehension-kindtracker scope is
            // bounded to the simple-identifier-on-closed-Range case;
            // broader pattern / iterable shapes are out of scope per
            // the cluster-1.5 W11-fup-B narrow charter).
            if let Expr::Range {
                start: Some(start_expr),
                end: Some(end_expr),
                ..
            } = clause.iterable.as_ref()
            {
                let _ = lower_expr_to_temp(builder, start_expr);
                let _ = lower_expr_to_temp(builder, end_expr);
            } else {
                let _ = lower_expr_to_temp(builder, &clause.iterable);
            }
            let element_slot = builder.alloc_temp(LocalTypeInfo::Unknown);
            assign_none(builder, element_slot, clause.iterable.span());
            super::stmt::lower_destructure_bindings_from_place(
                builder,
                &clause.pattern,
                &Place::Local(element_slot),
                clause.iterable.span(),
                None,
            );
            if let Some(filter) = &clause.filter {
                let _ = lower_expr_to_temp(builder, filter);
            }
        }
    }
    // W16.2-C (Round 6 WS-1, 2026-05-21): model the comprehension RESULT
    // as an array, not the bare element.
    //
    // Pre-fix this emitted `assign_copy_from_slot(temp, element_slot)` —
    // i.e. `temp = <element>`, which classified the comprehension result
    // slot as the element's scalar `ConcreteType` (e.g. `Int64` for
    // `[x for x in 0..5]`). The MIR here is not executed for the
    // comprehension (the bytecode compiler's `compile_list_comprehension`
    // lowers the real loop); the MIR feeds ONLY the
    // `top_level_local_concrete_types` conduit that the JIT reads to stamp
    // slot kinds. With `temp` mis-classified as a scalar, the JIT stamped
    // the comprehension's `let c = [...]` binding as `Int64` and a
    // downstream `c.len()` dispatched against an `Int64` receiver —
    // surfacing `no method 'len' on receiver kind Int64` (the W16.2-C
    // audit §5.D comprehension VM/JIT divergence).
    //
    // Emit a `StatementKind::ArrayStore { container_slot: temp,
    // operands: [element] }` instead — the same kind-source statement an
    // array literal `[element]` emits. The conduit's `ArrayStore` arm
    // (`infer_top_level_concrete_types_from_mir`) then classifies `temp`
    // as `Array(elem)` from the moved element operand. Per ADR-006 §2.7.5
    // the element expression's `ConcreteType` IS the proof of the
    // comprehension's element kind — no fabrication, no decode.
    let element_operand = lower_expr_as_moved_operand(builder, &comp.element);
    emit_container_store_if_needed(
        builder,
        ContainerStoreKind::Array,
        temp,
        vec![element_operand],
        span,
    );
    builder.pop_scope();
}

fn lower_from_query_expr(
    builder: &mut MirBuilder,
    from_query: &ast::FromQueryExpr,
    temp: SlotId,
    span: Span,
) {
    builder.push_scope();
    let _ = lower_expr_to_temp(builder, &from_query.source);
    let source_slot = builder.alloc_local(from_query.variable.clone(), LocalTypeInfo::Unknown);
    assign_none(builder, source_slot, from_query.source.span());

    for clause in &from_query.clauses {
        match clause {
            ast::QueryClause::Where(expr) => {
                let _ = lower_expr_to_temp(builder, expr);
            }
            ast::QueryClause::OrderBy(specs) => {
                for spec in specs {
                    let _ = lower_expr_to_temp(builder, &spec.key);
                }
            }
            ast::QueryClause::GroupBy {
                element,
                key,
                into_var,
            } => {
                let _ = lower_expr_to_temp(builder, element);
                let _ = lower_expr_to_temp(builder, key);
                if let Some(into_var) = into_var {
                    let group_slot =
                        builder.alloc_local(into_var.clone(), LocalTypeInfo::Unknown);
                    assign_none(builder, group_slot, key.span());
                }
            }
            ast::QueryClause::Join {
                variable,
                source,
                left_key,
                right_key,
                into_var,
            } => {
                let _ = lower_expr_to_temp(builder, source);
                let join_slot =
                    builder.alloc_local(variable.clone(), LocalTypeInfo::Unknown);
                assign_none(builder, join_slot, source.span());
                let _ = lower_expr_to_temp(builder, left_key);
                let _ = lower_expr_to_temp(builder, right_key);
                if let Some(into_var) = into_var {
                    let into_slot =
                        builder.alloc_local(into_var.clone(), LocalTypeInfo::Unknown);
                    assign_none(builder, into_slot, right_key.span());
                }
            }
            ast::QueryClause::Let { variable, value } => {
                let value_slot = lower_expr_to_temp(builder, value);
                let local_slot =
                    builder.alloc_local(variable.clone(), LocalTypeInfo::Unknown);
                assign_copy_from_slot(builder, local_slot, value_slot, value.span());
            }
        }
    }

    let select_slot = lower_expr_to_temp(builder, &from_query.select);
    assign_copy_from_slot(builder, temp, select_slot, span);
    builder.pop_scope();
}

fn lower_comptime_expr(
    builder: &mut MirBuilder,
    stmts: &[Statement],
    temp: SlotId,
    span: Span,
) {
    builder.push_scope();
    let exit_block = builder.exit_block();
    lower_statements(builder, stmts, exit_block);
    assign_none(builder, temp, span);
    builder.pop_scope();
}

fn lower_comptime_for_expr(
    builder: &mut MirBuilder,
    comptime_for: &ast::ComptimeForExpr,
    temp: SlotId,
    span: Span,
) {
    builder.push_scope();
    let _ = lower_expr_to_temp(builder, &comptime_for.iterable);
    let local_slot =
        builder.alloc_local(comptime_for.variable.clone(), LocalTypeInfo::Unknown);
    assign_none(builder, local_slot, comptime_for.iterable.span());
    let exit_block = builder.exit_block();
    lower_statements(builder, &comptime_for.body, exit_block);
    assign_none(builder, temp, span);
    builder.pop_scope();
}

// ---------------------------------------------------------------------------
// Complex expression lowering (control-flow subgraphs)
// ---------------------------------------------------------------------------

pub(super) fn lower_conditional_expr(
    builder: &mut MirBuilder,
    condition: &Expr,
    then_expr: &Expr,
    else_expr: Option<&Expr>,
    temp: SlotId,
    span: Span,
) {
    let cond_slot = lower_expr_to_temp(builder, condition);
    let then_block = builder.new_block();
    let else_block = builder.new_block();
    let merge_block = builder.new_block();

    builder.finish_block(
        TerminatorKind::SwitchBool {
            operand: Operand::Copy(Place::Local(cond_slot)),
            true_bb: then_block,
            false_bb: else_block,
        },
        span,
    );

    builder.start_block(then_block);
    let then_slot = lower_expr_to_temp(builder, then_expr);
    builder.push_stmt(
        StatementKind::Assign(
            Place::Local(temp),
            Rvalue::Use(Operand::Copy(Place::Local(then_slot))),
        ),
        then_expr.span(),
    );
    builder.finish_block(TerminatorKind::Goto(merge_block), then_expr.span());

    builder.start_block(else_block);
    if let Some(else_expr) = else_expr {
        let else_slot = lower_expr_to_temp(builder, else_expr);
        builder.push_stmt(
            StatementKind::Assign(
                Place::Local(temp),
                Rvalue::Use(Operand::Copy(Place::Local(else_slot))),
            ),
            else_expr.span(),
        );
        builder.finish_block(TerminatorKind::Goto(merge_block), else_expr.span());
    } else {
        builder.push_stmt(
            StatementKind::Assign(
                Place::Local(temp),
                Rvalue::Use(Operand::Constant(MirConstant::None)),
            ),
            span,
        );
        builder.finish_block(TerminatorKind::Goto(merge_block), span);
    }

    builder.start_block(merge_block);
}

/// Lower the null coalescing operator `lhs ?? rhs`.
///
/// Generates:
///   _lhs = evaluate(lhs)
///   _is_null = Eq(_lhs, None)
///   SwitchBool(_is_null, true=null_bb, false=non_null_bb)
///
///   null_bb:
///     temp = evaluate(rhs)
///     Goto(merge_bb)
///
///   non_null_bb:
///     temp = _lhs
///     Goto(merge_bb)
///
///   merge_bb:
///     // temp holds the result
fn lower_null_coalesce(
    builder: &mut MirBuilder,
    lhs: &Expr,
    rhs: &Expr,
    temp: SlotId,
    span: Span,
) {
    // Evaluate LHS
    let lhs_slot = lower_expr_to_temp(builder, lhs);

    // Check if LHS is null: compare with None
    let is_null_slot = builder.alloc_temp(LocalTypeInfo::Unknown);
    builder.push_stmt(
        StatementKind::Assign(
            Place::Local(is_null_slot),
            Rvalue::BinaryOp(
                BinOp::Eq,
                Operand::Copy(Place::Local(lhs_slot)),
                Operand::Constant(MirConstant::None),
            ),
        ),
        span,
    );

    let null_bb = builder.new_block();
    let non_null_bb = builder.new_block();
    let merge_bb = builder.new_block();

    builder.finish_block(
        TerminatorKind::SwitchBool {
            operand: Operand::Copy(Place::Local(is_null_slot)),
            true_bb: null_bb,
            false_bb: non_null_bb,
        },
        span,
    );

    // null_bb: LHS was None, evaluate RHS
    builder.start_block(null_bb);
    let rhs_slot = lower_expr_to_temp(builder, rhs);
    builder.push_stmt(
        StatementKind::Assign(
            Place::Local(temp),
            Rvalue::Use(Operand::Copy(Place::Local(rhs_slot))),
        ),
        rhs.span(),
    );
    builder.finish_block(TerminatorKind::Goto(merge_bb), rhs.span());

    // non_null_bb: LHS was not None, use it directly
    builder.start_block(non_null_bb);
    builder.push_stmt(
        StatementKind::Assign(
            Place::Local(temp),
            Rvalue::Use(Operand::Copy(Place::Local(lhs_slot))),
        ),
        lhs.span(),
    );
    builder.finish_block(TerminatorKind::Goto(merge_bb), lhs.span());

    builder.start_block(merge_bb);
}

/// Lower a short-circuiting logical `&&` or `||` per ADR-006 §2.7.5
/// producer-side stamp + Phase 4b Round 5c-2-α jit-shortcircuit-eager
/// soundness fix (2026-05-19; sister-class to LANG-9-spin-3-first).
///
/// The bytecode VM compiler emits short-circuit jumps directly in
/// `crates/shape-vm/src/compiler/expressions/binary_ops.rs:723-754`
/// (`compile_expr_binary_op` arms for `BinaryOp::And` / `BinaryOp::Or`),
/// but the MIR lowering pre-fix eagerly evaluated both operands and
/// emitted `Rvalue::BinaryOp(BinOp::And|Or, l, r)` (this file's
/// `Expr::BinaryOp` arm). The JIT (`crates/shape-jit/src/mir_compiler/
/// rvalues.rs:840-841`) compiled those as `band`/`bor` — eager bitwise
/// — so the JIT observably evaluated the RHS even when the LHS was
/// already truthy (for `||`) or falsy (for `&&`). The empirical t25
/// reproducer (W15.2-A close commit `7cbc316b`): `side("a", true) ||
/// side("b", true)` prints `a\ntrue` under VM (short-circuited) vs
/// `a\nb\ntrue` under JIT (eager) — a v0.3-gating SOUNDNESS BUG.
///
/// Fix shape per W14.2-G4-derefstore-drift / LANG-9-spin-3-first
/// precedent: surgical producer-side fix at the MIR lowering layer
/// (where both VM and JIT downstream consumers diverge from), mirroring
/// the existing `lower_null_coalesce` template. Generates:
///
///   _lhs = evaluate(lhs)
///   SwitchBool(_lhs, true=eval_rhs_bb, false=short_circuit_bb)   ; for &&
///   (or)
///   SwitchBool(_lhs, true=short_circuit_bb, false=eval_rhs_bb)   ; for ||
///
///   eval_rhs_bb:
///     _rhs = evaluate(rhs)
///     SwitchBool(_rhs, true=set_true_bb, false=set_false_bb)
///   set_true_bb:
///     temp = true
///     Goto(merge_bb)
///   set_false_bb:
///     temp = false
///     Goto(merge_bb)
///
///   short_circuit_bb:
///     temp = false (for &&) / true (for ||)
///     Goto(merge_bb)
///
///   merge_bb:
///     // temp holds the result as `MirConstant::Bool` (always normalized
///     // to a real bool — matches the bytecode VM's `Not Not` normalize
///     // pattern at `compiler/expressions/binary_ops.rs:728-729`).
fn lower_short_circuit_and_or(
    builder: &mut MirBuilder,
    lhs: &Expr,
    op: ast::BinaryOp,
    rhs: &Expr,
    temp: SlotId,
    span: Span,
) {
    debug_assert!(matches!(op, ast::BinaryOp::And | ast::BinaryOp::Or));
    let is_and = matches!(op, ast::BinaryOp::And);

    // Evaluate LHS first.
    let lhs_slot = lower_expr_to_temp(builder, lhs);

    let eval_rhs_bb = builder.new_block();
    let short_circuit_bb = builder.new_block();
    let set_true_bb = builder.new_block();
    let set_false_bb = builder.new_block();
    let merge_bb = builder.new_block();

    // For `&&`: lhs truthy -> eval rhs; lhs falsy -> short-circuit with false.
    // For `||`: lhs truthy -> short-circuit with true; lhs falsy -> eval rhs.
    let (true_bb, false_bb) = if is_and {
        (eval_rhs_bb, short_circuit_bb)
    } else {
        (short_circuit_bb, eval_rhs_bb)
    };
    builder.finish_block(
        TerminatorKind::SwitchBool {
            operand: Operand::Copy(Place::Local(lhs_slot)),
            true_bb,
            false_bb,
        },
        span,
    );

    // eval_rhs_bb: lhs did not short-circuit; evaluate rhs and normalize to
    // a real bool via a second SwitchBool (mirrors the bytecode VM's
    // `Not Not` normalize sequence at `compiler/expressions/
    // binary_ops.rs:728-729`).
    builder.start_block(eval_rhs_bb);
    let rhs_slot = lower_expr_to_temp(builder, rhs);
    builder.finish_block(
        TerminatorKind::SwitchBool {
            operand: Operand::Copy(Place::Local(rhs_slot)),
            true_bb: set_true_bb,
            false_bb: set_false_bb,
        },
        rhs.span(),
    );

    builder.start_block(set_true_bb);
    builder.push_stmt(
        StatementKind::Assign(
            Place::Local(temp),
            Rvalue::Use(Operand::Constant(MirConstant::Bool(true))),
        ),
        rhs.span(),
    );
    builder.finish_block(TerminatorKind::Goto(merge_bb), rhs.span());

    builder.start_block(set_false_bb);
    builder.push_stmt(
        StatementKind::Assign(
            Place::Local(temp),
            Rvalue::Use(Operand::Constant(MirConstant::Bool(false))),
        ),
        rhs.span(),
    );
    builder.finish_block(TerminatorKind::Goto(merge_bb), rhs.span());

    // short_circuit_bb: lhs determined the result.
    // For `&&`: lhs was falsy -> result is false.
    // For `||`: lhs was truthy -> result is true.
    builder.start_block(short_circuit_bb);
    let short_circuit_value = !is_and; // && -> false, || -> true
    builder.push_stmt(
        StatementKind::Assign(
            Place::Local(temp),
            Rvalue::Use(Operand::Constant(MirConstant::Bool(short_circuit_value))),
        ),
        span,
    );
    builder.finish_block(TerminatorKind::Goto(merge_bb), span);

    builder.start_block(merge_bb);
}

/// Lower a formatted string literal `f"text {expr} more"` into a series
/// of string constant / expression evaluations concatenated with BinOp::Add.
fn lower_formatted_string(
    builder: &mut MirBuilder,
    value: &str,
    mode: shape_ast::ast::InterpolationMode,
    temp: SlotId,
    span: Span,
) {
    let parts = match parse_interpolation_with_mode(value, mode) {
        Ok(parts) => parts,
        Err(_) => {
            // Fallback: emit empty string on parse error
            builder.push_stmt(
                StatementKind::Assign(
                    Place::Local(temp),
                    Rvalue::Use(Operand::Constant(MirConstant::Str(String::new()))),
                ),
                span,
            );
            return;
        }
    };

    if parts.is_empty() {
        builder.push_stmt(
            StatementKind::Assign(
                Place::Local(temp),
                Rvalue::Use(Operand::Constant(MirConstant::Str(String::new()))),
            ),
            span,
        );
        return;
    }

    // Lower each part to a slot, then concatenate with BinOp::Add
    let mut accumulated: Option<SlotId> = None;

    for part in parts {
        let part_slot = match part {
            InterpolationPart::Literal(text) => {
                let s = builder.alloc_temp(LocalTypeInfo::Unknown);
                builder.push_stmt(
                    StatementKind::Assign(
                        Place::Local(s),
                        Rvalue::Use(Operand::Constant(MirConstant::Str(text))),
                    ),
                    span,
                );
                s
            }
            InterpolationPart::Expression { expr, .. } => {
                // Parse and lower the expression
                match shape_ast::parser::parse_expression_str(&expr) {
                    Ok(parsed_expr) => lower_expr_to_temp(builder, &parsed_expr),
                    Err(_) => {
                        // Fallback: emit empty string on parse error
                        let s = builder.alloc_temp(LocalTypeInfo::Unknown);
                        builder.push_stmt(
                            StatementKind::Assign(
                                Place::Local(s),
                                Rvalue::Use(Operand::Constant(MirConstant::Str(String::new()))),
                            ),
                            span,
                        );
                        s
                    }
                }
            }
        };

        accumulated = Some(match accumulated {
            None => part_slot,
            Some(prev_slot) => {
                // Concatenate prev_slot + part_slot using BinOp::Add
                let concat_slot = builder.alloc_temp(LocalTypeInfo::Unknown);
                builder.push_stmt(
                    StatementKind::Assign(
                        Place::Local(concat_slot),
                        Rvalue::BinaryOp(
                            BinOp::Add,
                            Operand::Copy(Place::Local(prev_slot)),
                            Operand::Copy(Place::Local(part_slot)),
                        ),
                    ),
                    span,
                );
                concat_slot
            }
        });
    }

    // Copy final result to temp
    if let Some(result_slot) = accumulated {
        builder.push_stmt(
            StatementKind::Assign(
                Place::Local(temp),
                Rvalue::Use(Operand::Copy(Place::Local(result_slot))),
            ),
            span,
        );
    } else {
        builder.push_stmt(
            StatementKind::Assign(
                Place::Local(temp),
                Rvalue::Use(Operand::Constant(MirConstant::Str(String::new()))),
            ),
            span,
        );
    }
}

fn lower_block_expr(
    builder: &mut MirBuilder,
    block: &ast::BlockExpr,
    temp: SlotId,
    span: Span,
) {
    builder.push_scope();

    if block.items.is_empty() {
        builder.push_stmt(
            StatementKind::Assign(
                Place::Local(temp),
                Rvalue::Use(Operand::Constant(MirConstant::None)),
            ),
            span,
        );
        builder.pop_scope();
        return;
    }

    let last_idx = block.items.len() - 1;
    for (idx, item) in block.items.iter().enumerate() {
        let is_last = idx == last_idx;
        match item {
            ast::BlockItem::VariableDecl(decl) => {
                lower_var_decl(builder, decl, span);
                if is_last {
                    builder.push_stmt(
                        StatementKind::Assign(
                            Place::Local(temp),
                            Rvalue::Use(Operand::Constant(MirConstant::None)),
                        ),
                        span,
                    );
                }
            }
            ast::BlockItem::Assignment(assign) => {
                super::stmt::lower_assignment(builder, assign, span);
                if is_last {
                    builder.push_stmt(
                        StatementKind::Assign(
                            Place::Local(temp),
                            Rvalue::Use(Operand::Constant(MirConstant::None)),
                        ),
                        span,
                    );
                }
            }
            ast::BlockItem::Expression(expr) => {
                let expr_slot = lower_expr_to_temp(builder, expr);
                if is_last {
                    builder.push_stmt(
                        StatementKind::Assign(
                            Place::Local(temp),
                            Rvalue::Use(Operand::Copy(Place::Local(expr_slot))),
                        ),
                        expr.span(),
                    );
                }
            }
            ast::BlockItem::Statement(stmt) => {
                lower_statement(builder, stmt, builder.exit_block(), false);
                if is_last {
                    builder.push_stmt(
                        StatementKind::Assign(
                            Place::Local(temp),
                            Rvalue::Use(Operand::Constant(MirConstant::None)),
                        ),
                        stmt.span().unwrap_or(span),
                    );
                }
            }
        }
    }

    builder.pop_scope();
}

fn lower_let_expr(
    builder: &mut MirBuilder,
    let_expr: &ast::LetExpr,
    temp: SlotId,
    span: Span,
) {
    builder.push_scope();

    if let Some(name) = let_expr.pattern.as_simple_name() {
        let slot = builder.alloc_local(name.to_string(), LocalTypeInfo::Unknown);
        if let Some(value) = &let_expr.value {
            let operand = lower_expr_to_operand(builder, value, true);
            builder.push_stmt(
                StatementKind::Assign(Place::Local(slot), Rvalue::Use(operand)),
                value.span(),
            );
        } else {
            builder.push_stmt(
                StatementKind::Assign(
                    Place::Local(slot),
                    Rvalue::Use(Operand::Constant(MirConstant::None)),
                ),
                span,
            );
        }
    } else {
        let source_place = if let Some(value) = &let_expr.value {
            let source_slot = lower_expr_to_temp(builder, value);
            Some(Place::Local(source_slot))
        } else {
            None
        };
        super::stmt::lower_pattern_bindings_from_place_opt(
            builder,
            &let_expr.pattern,
            source_place.as_ref(),
            span,
            Some(immutable_binding_metadata(span, false, false)),
        );
    }

    let body_slot = lower_expr_to_temp(builder, &let_expr.body);
    builder.push_stmt(
        StatementKind::Assign(
            Place::Local(temp),
            Rvalue::Use(Operand::Copy(Place::Local(body_slot))),
        ),
        let_expr.body.span(),
    );

    builder.pop_scope();
}

fn lower_while_expr(
    builder: &mut MirBuilder,
    while_expr: &ast::WhileExpr,
    temp: SlotId,
    span: Span,
) {
    let header = builder.new_block();
    let body_block = builder.new_block();
    let after = builder.new_block();

    builder.push_stmt(
        StatementKind::Assign(
            Place::Local(temp),
            Rvalue::Use(Operand::Constant(MirConstant::None)),
        ),
        span,
    );
    builder.finish_block(TerminatorKind::Goto(header), span);

    builder.start_block(header);
    let cond_slot = lower_expr_to_temp(builder, &while_expr.condition);
    builder.finish_block(
        TerminatorKind::SwitchBool {
            operand: Operand::Copy(Place::Local(cond_slot)),
            true_bb: body_block,
            false_bb: after,
        },
        span,
    );

    builder.start_block(body_block);
    builder.push_loop(after, header, Some(temp));
    let body_slot = lower_expr_to_temp(builder, &while_expr.body);
    builder.push_stmt(
        StatementKind::Assign(
            Place::Local(temp),
            Rvalue::Use(Operand::Copy(Place::Local(body_slot))),
        ),
        while_expr.body.span(),
    );
    builder.pop_loop();
    builder.finish_block(TerminatorKind::Goto(header), span);

    builder.start_block(after);
}

fn lower_for_expr(
    builder: &mut MirBuilder,
    for_expr: &ast::ForExpr,
    temp: SlotId,
    span: Span,
) {
    // Check if the iterable is a Range expression with both start and end.
    // If so, generate a counter-based loop (like the bytecode compiler does).
    if let Expr::Range {
        start: Some(start_expr),
        end: Some(end_expr),
        kind,
        ..
    } = for_expr.iterable.as_ref()
    {
        use shape_ast::ast::RangeKind;

        builder.push_scope();

        // Evaluate start and end into temp slots
        let start_slot = lower_expr_to_temp(builder, start_expr);
        let end_slot = lower_expr_to_temp(builder, end_expr);

        // Allocate the loop counter as a named local so the loop body
        // can reference it by name. For simple identifier patterns
        // (the common case: `for i in 0..10`), the counter IS the
        // loop variable.
        let counter_slot = match &for_expr.pattern {
            ast::Pattern::Identifier(name) | ast::Pattern::Typed { name, .. } => {
                builder.alloc_local(name.clone(), LocalTypeInfo::Unknown)
            }
            _ => builder.alloc_temp(LocalTypeInfo::Unknown),
        };

        // Initialize counter = start
        builder.push_stmt(
            StatementKind::Assign(
                Place::Local(counter_slot),
                Rvalue::Use(Operand::Copy(Place::Local(start_slot))),
            ),
            span,
        );

        // Initialize result temp to None (for-expr may produce a value)
        builder.push_stmt(
            StatementKind::Assign(
                Place::Local(temp),
                Rvalue::Use(Operand::Constant(MirConstant::None)),
            ),
            span,
        );

        let header = builder.new_block();
        let body_block = builder.new_block();
        // Per W15.2-LANG-2 (2026-05-18) — see stmt.rs::lower_for_loop
        // ForIn arm for the design comment. The MIR for-range expr lowers
        // its post-body counter increment into a dedicated
        // `continue_target` block so that `continue` inside the body
        // performs the increment exactly once per iteration; without
        // this, `for i in 0..10 { if i==2 { continue } ... }` infinite-
        // loops at i=2 because `continue → header` skips the counter
        // advance and re-enters the body with idx unchanged.
        let continue_target = builder.new_block();
        let after = builder.new_block();

        builder.finish_block(TerminatorKind::Goto(header), span);

        // Loop header: check counter < end (or counter <= end for inclusive)
        builder.start_block(header);
        let cmp_op = match kind {
            RangeKind::Exclusive => BinOp::Lt,
            RangeKind::Inclusive => BinOp::Le,
        };
        let cond_slot = builder.alloc_temp(LocalTypeInfo::Unknown);
        builder.push_stmt(
            StatementKind::Assign(
                Place::Local(cond_slot),
                Rvalue::BinaryOp(
                    cmp_op,
                    Operand::Copy(Place::Local(counter_slot)),
                    Operand::Copy(Place::Local(end_slot)),
                ),
            ),
            span,
        );
        builder.finish_block(
            TerminatorKind::SwitchBool {
                operand: Operand::Copy(Place::Local(cond_slot)),
                true_bb: body_block,
                false_bb: after,
            },
            span,
        );

        // Loop body
        builder.start_block(body_block);
        builder.push_loop(after, continue_target, Some(temp));
        let body_slot = lower_expr_to_temp(builder, &for_expr.body);
        builder.push_stmt(
            StatementKind::Assign(
                Place::Local(temp),
                Rvalue::Use(Operand::Copy(Place::Local(body_slot))),
            ),
            for_expr.body.span(),
        );
        builder.pop_loop();

        // Body fall-through → continue_target → increment → header.
        builder.finish_block(TerminatorKind::Goto(continue_target), span);

        // continue_target: counter = counter + 1; goto header.
        builder.start_block(continue_target);
        builder.push_stmt(
            StatementKind::Assign(
                Place::Local(counter_slot),
                Rvalue::BinaryOp(
                    BinOp::Add,
                    Operand::Copy(Place::Local(counter_slot)),
                    Operand::Constant(MirConstant::Int(1)),
                ),
            ),
            span,
        );

        builder.finish_block(TerminatorKind::Goto(header), span);

        // After loop
        builder.start_block(after);
        builder.pop_scope();
    } else {
        // Generic (non-Range) iterator path. Lowered as an index-counter
        // state machine over the iterable's length: pre-compute
        // `__len = iter.len()`, then loop `idx in 0..__len` reading
        // `iter[idx]` per iteration.
        //
        // cluster-2-closure-wave-1-iter-statemachine (2026-05-16):
        // replaces the prior placeholder stub
        // (`iter_slot SwitchBool` truthiness + unconditional Goto(header),
        // no advance, no termination) that caused Smoke 2 JIT
        // (`xs.map(|x|x*2).sum()`) to infinite-loop inside the
        // specialized `Vec.map::i64_i64_closure_*` body at runtime
        // (rc=124 TIMEOUT) — empirically dispositioned at
        // `docs/cluster-audits/cluster-2-v3s6f-empirical-verification.md`
        // §2 hypothesis (a) CONFIRMED. Bytecode-VM-side reference
        // implementation: `crates/shape-vm/src/compiler/loops.rs:298-518`
        // (`compile_for_loop` ForIn arm, which uses bytecode-level
        // `IterDone`/`IterNext` opcodes; the MIR layer does not have
        // those opcodes available so we use the `len()` / `[idx]`
        // shape per the empirical-verification deliverable §2.5
        // recommendation, "Approach (ii) — reuses existing MIR
        // vocabulary, no new StatementKind variants").
        //
        // ADR-006 §2.7.5 stamp-at-compile-time: the iterable's
        // ConcreteType drives method dispatch at runtime via the JIT's
        // existing v2 typed-array `len`/index fast paths (e.g.
        // `crates/shape-jit/src/mir_compiler/v2_array.rs::try_emit_v2_array_method`
        // for `len`, `places.rs:909-918` for `Place::Index` over a
        // v2 typed-array slot). Non-typed-array iterables fall through
        // to the trampoline `jit_call_method("len")` + generic
        // `inline_array_get` paths, which already handle Array /
        // HashMap-keys / etc. uniformly.
        //
        // ADR-006 §2.7.7 #4 / #7 NOT violated: there is no runtime tag
        // dispatch in the emitted MIR — the JIT compiler picks the
        // correct codegen per iterable's compile-time ConcreteType at
        // its consumer site. The MIR shape is uniform across iterable
        // types (Call+Index+Add+Lt), and the per-iterable
        // monomorphization happens downstream of MIR.
        //
        // Lowering shape (mirrors the bytecode-VM-side state machine):
        //
        //   bb_pre:
        //     iter_slot = <iterable expr>
        //     __idx = 0
        //     __len = iter_slot.len()   ; Call terminator (next=bb_header)
        //     temp = none                ; for-expr produces unit/None
        //     goto bb_header
        //   bb_header:
        //     __cond = __idx < __len     ; BinaryOp::Lt
        //     switchbool __cond -> bb_body, bb_after
        //   bb_body:
        //     __elem = iter_slot[__idx]  ; via Place::Index
        //     <destructure pattern from __elem>
        //     <body, may break / continue>
        //     __idx = __idx + 1
        //     goto bb_header
        //   bb_after:
        builder.push_scope();

        let iter_slot = lower_expr_to_temp(builder, &for_expr.iterable);

        // Counter slot and length slot are pure internal MIR temps.
        // Both hold integer values (LocalTypeInfo::Copy → JIT will
        // stamp Int64 via slot-kind inference).
        let idx_slot = builder.alloc_temp(LocalTypeInfo::Copy);
        let len_slot = builder.alloc_temp(LocalTypeInfo::Copy);

        // __idx = 0
        builder.push_stmt(
            StatementKind::Assign(
                Place::Local(idx_slot),
                Rvalue::Use(Operand::Constant(MirConstant::Int(0))),
            ),
            span,
        );

        // __len = iter_slot.len()  — emit as a Call terminator with
        // MirConstant::Method("len"). The JIT's v2 typed-array fast
        // path intercepts this at `terminators.rs:108-135` for
        // typed-array receivers; non-typed-array iterables fall
        // through to `jit_call_method("len", [iter_slot])`. Either
        // way, the destination slot receives an i64 length.
        let len_call_func = Operand::Constant(MirConstant::Method("len".to_string()));
        builder.emit_call(
            len_call_func,
            vec![Operand::Copy(Place::Local(iter_slot))],
            Place::Local(len_slot),
            span,
        );

        // The for-expr's result value defaults to None; the body's
        // last expression overwrites it per iteration (matching the
        // Range-case behaviour above and the bytecode-VM-side break-
        // with-value semantics).
        builder.push_stmt(
            StatementKind::Assign(
                Place::Local(temp),
                Rvalue::Use(Operand::Constant(MirConstant::None)),
            ),
            span,
        );

        let header = builder.new_block();
        let body_block = builder.new_block();
        // Per W15.2-LANG-2 (2026-05-18) — see stmt.rs::lower_for_loop
        // ForIn arm for the design comment. Generic-iterator expr-form
        // for-loop routes `continue` through a dedicated continue_target
        // block that performs the index advance so the body's `continue`
        // does not infinite-loop by skipping the increment.
        let continue_target = builder.new_block();
        let after = builder.new_block();

        builder.finish_block(TerminatorKind::Goto(header), span);

        // Loop header: __cond = __idx < __len; switchbool __cond.
        builder.start_block(header);
        let cond_slot = builder.alloc_temp(LocalTypeInfo::Copy);
        builder.push_stmt(
            StatementKind::Assign(
                Place::Local(cond_slot),
                Rvalue::BinaryOp(
                    BinOp::Lt,
                    Operand::Copy(Place::Local(idx_slot)),
                    Operand::Copy(Place::Local(len_slot)),
                ),
            ),
            span,
        );
        builder.finish_block(
            TerminatorKind::SwitchBool {
                operand: Operand::Copy(Place::Local(cond_slot)),
                true_bb: body_block,
                false_bb: after,
            },
            span,
        );

        // Loop body: read iter_slot[__idx] into a fresh element slot,
        // destructure pattern bindings, lower the user body, increment
        // counter, goto header.
        builder.start_block(body_block);

        // Allocate the destructure-source slot as either the pattern's
        // own named slot (single-identifier patterns: avoids one
        // intermediate copy and matches the bytecode-VM-side path) or
        // an anonymous temp (compound patterns: destructured downstream).
        let elem_slot = match &for_expr.pattern {
            ast::Pattern::Identifier(name) | ast::Pattern::Typed { name, .. } => {
                builder.alloc_local(name.clone(), LocalTypeInfo::Unknown)
            }
            _ => builder.alloc_temp(LocalTypeInfo::Unknown),
        };

        // __elem = iter_slot[__idx]  — Place::Index lowering. JIT v2
        // typed-array fast path at `places.rs:909-918` emits an
        // inline `v2_array_get(arr_ptr, idx_i32, elem_kind)` for
        // typed-array bases; generic arrays fall back to
        // `inline_array_get`. Both produce an i64-shaped element
        // value in the destination slot.
        let index_place = Place::Index(
            Box::new(Place::Local(iter_slot)),
            Box::new(Operand::Copy(Place::Local(idx_slot))),
        );
        builder.push_stmt(
            StatementKind::Assign(
                Place::Local(elem_slot),
                Rvalue::Use(Operand::Copy(index_place)),
            ),
            span,
        );

        // Bind compound patterns from the element slot; single-
        // identifier patterns already have `elem_slot` aliased to
        // the pattern name above (the destructure walker no-ops for
        // matching identifier patterns since `lookup_local(name)`
        // resolves to the slot we just allocated).
        if !matches!(
            &for_expr.pattern,
            ast::Pattern::Identifier(_) | ast::Pattern::Typed { .. }
        ) {
            super::stmt::lower_pattern_bindings_from_place(
                builder,
                &for_expr.pattern,
                &Place::Local(elem_slot),
                span,
                None,
            );
        }

        builder.push_loop(after, continue_target, Some(temp));
        let body_slot = lower_expr_to_temp(builder, &for_expr.body);
        builder.push_stmt(
            StatementKind::Assign(
                Place::Local(temp),
                Rvalue::Use(Operand::Copy(Place::Local(body_slot))),
            ),
            for_expr.body.span(),
        );
        builder.pop_loop();

        // Body fall-through → continue_target → increment → header.
        builder.finish_block(TerminatorKind::Goto(continue_target), span);

        // continue_target: __idx = __idx + 1; goto header.
        builder.start_block(continue_target);
        builder.push_stmt(
            StatementKind::Assign(
                Place::Local(idx_slot),
                Rvalue::BinaryOp(
                    BinOp::Add,
                    Operand::Copy(Place::Local(idx_slot)),
                    Operand::Constant(MirConstant::Int(1)),
                ),
            ),
            span,
        );

        builder.finish_block(TerminatorKind::Goto(header), span);

        // After loop
        builder.start_block(after);
        builder.pop_scope();
    }
}

fn lower_loop_expr(
    builder: &mut MirBuilder,
    loop_expr: &ast::LoopExpr,
    temp: SlotId,
    span: Span,
) {
    let body_block = builder.new_block();
    let after = builder.new_block();

    builder.push_stmt(
        StatementKind::Assign(
            Place::Local(temp),
            Rvalue::Use(Operand::Constant(MirConstant::None)),
        ),
        span,
    );
    builder.finish_block(TerminatorKind::Goto(body_block), span);

    builder.start_block(body_block);
    builder.push_loop(after, body_block, Some(temp));
    let body_slot = lower_expr_to_temp(builder, &loop_expr.body);
    builder.push_stmt(
        StatementKind::Assign(
            Place::Local(temp),
            Rvalue::Use(Operand::Copy(Place::Local(body_slot))),
        ),
        loop_expr.body.span(),
    );
    builder.pop_loop();
    builder.finish_block(TerminatorKind::Goto(body_block), span);

    builder.start_block(after);
}

pub(super) fn lower_match_expr(
    builder: &mut MirBuilder,
    match_expr: &ast::MatchExpr,
    temp: SlotId,
    span: Span,
) {
    if match_expr.arms.is_empty() {
        builder.push_stmt(
            StatementKind::Assign(
                Place::Local(temp),
                Rvalue::Use(Operand::Constant(MirConstant::None)),
            ),
            span,
        );
        return;
    }

    let scrutinee_slot = lower_expr_to_temp(builder, &match_expr.scrutinee);
    let merge_block = builder.new_block();
    let no_match_block = builder.new_block();
    let mut next_test_block = builder.current_block;

    for (idx, arm) in match_expr.arms.iter().enumerate() {
        if idx > 0 {
            builder.start_block(next_test_block);
        }

        let body_block = builder.new_block();
        let next_block = if idx + 1 < match_expr.arms.len() {
            builder.new_block()
        } else {
            no_match_block
        };
        let pattern_span = arm.pattern_span.unwrap_or(span);
        let mut binding_scope_active = false;
        if super::stmt::pattern_has_bindings(&arm.pattern) {
            builder.push_scope();
            binding_scope_active = true;
            super::stmt::lower_pattern_bindings_from_place(
                builder,
                &arm.pattern,
                &Place::Local(scrutinee_slot),
                pattern_span,
                Some(immutable_binding_metadata(pattern_span, false, false)),
            );
        }

        if let Some(pattern_operand) = lower_match_pattern_condition_operand(
            builder,
            &arm.pattern,
            scrutinee_slot,
            pattern_span,
        ) {
            if let Some(guard) = &arm.guard {
                let guard_block = builder.new_block();
                builder.finish_block(
                    TerminatorKind::SwitchBool {
                        operand: pattern_operand,
                        true_bb: guard_block,
                        false_bb: next_block,
                    },
                    pattern_span,
                );
                builder.start_block(guard_block);
                let guard_slot = lower_expr_to_temp(builder, guard);
                builder.finish_block(
                    TerminatorKind::SwitchBool {
                        operand: Operand::Copy(Place::Local(guard_slot)),
                        true_bb: body_block,
                        false_bb: next_block,
                    },
                    guard.span(),
                );
            } else {
                builder.finish_block(
                    TerminatorKind::SwitchBool {
                        operand: pattern_operand,
                        true_bb: body_block,
                        false_bb: next_block,
                    },
                    pattern_span,
                );
            }
        } else if let Some(guard) = &arm.guard {
            let guard_slot = lower_expr_to_temp(builder, guard);
            builder.finish_block(
                TerminatorKind::SwitchBool {
                    operand: Operand::Copy(Place::Local(guard_slot)),
                    true_bb: body_block,
                    false_bb: next_block,
                },
                guard.span(),
            );
        } else {
            builder.finish_block(TerminatorKind::Goto(body_block), pattern_span);
        }

        builder.start_block(body_block);
        let body_slot = lower_expr_to_temp(builder, &arm.body);
        builder.push_stmt(
            StatementKind::Assign(
                Place::Local(temp),
                Rvalue::Use(Operand::Copy(Place::Local(body_slot))),
            ),
            arm.body.span(),
        );
        builder.finish_block(TerminatorKind::Goto(merge_block), arm.body.span());

        if binding_scope_active {
            builder.pop_scope();
        }
        next_test_block = next_block;
    }

    builder.start_block(no_match_block);
    builder.push_stmt(
        StatementKind::Assign(
            Place::Local(temp),
            Rvalue::Use(Operand::Constant(MirConstant::None)),
        ),
        span,
    );
    builder.finish_block(TerminatorKind::Goto(merge_block), span);

    builder.start_block(merge_block);
}

fn lower_match_pattern_condition_operand(
    builder: &mut MirBuilder,
    pattern: &ast::Pattern,
    scrutinee_slot: SlotId,
    pattern_span: Span,
) -> Option<Operand> {
    match pattern {
        ast::Pattern::Identifier(_) | ast::Pattern::Wildcard => None,
        ast::Pattern::Typed {
            type_annotation, ..
        } => {
            // W15.2-LANG-5 (Phase 4b, 2026-05-18). Pre-fix this arm was
            // grouped with `Identifier`/`Wildcard` and returned `None` —
            // the MIR builder then emitted `TerminatorKind::Goto(body_block)`
            // with no discriminator, so under JIT every typed-pattern arm
            // unconditionally took the first arm (e.g. `match x { n: int
            // => 100, s: string => 200 }` on a union `int | string`
            // scrutinee returned 100 for both inputs).
            //
            // Producer-side stamp-at-compile-time per ADR-006 §2.7.5: the
            // type annotation is captured verbatim into `Rvalue::
            // TypePatternTest` so the consumer dispatches on a known kind
            // (not on raw bits, not on a Bool-default fabrication). The
            // JIT consumer's preflight rejects this Rvalue today, routing
            // the program through the W12 fall-through to the bytecode
            // interpreter (which compiles `Pattern::Typed` via the
            // `OpCode::TypeCheck` path in `compiler/patterns/checking.rs`).
            let bool_slot = builder.alloc_temp(LocalTypeInfo::Copy);
            builder.push_stmt(
                StatementKind::Assign(
                    Place::Local(bool_slot),
                    Rvalue::TypePatternTest {
                        operand: Operand::Copy(Place::Local(scrutinee_slot)),
                        type_annotation: type_annotation.clone(),
                    },
                ),
                pattern_span,
            );
            Some(Operand::Copy(Place::Local(bool_slot)))
        }
        ast::Pattern::Literal(literal) => {
            let literal_expr = Expr::Literal(literal.clone(), pattern_span);
            let literal_operand = lower_expr_to_operand(builder, &literal_expr, false);
            let matches_slot = builder.alloc_temp(LocalTypeInfo::Copy);
            builder.push_stmt(
                StatementKind::Assign(
                    Place::Local(matches_slot),
                    Rvalue::BinaryOp(
                        BinOp::Eq,
                        Operand::Copy(Place::Local(scrutinee_slot)),
                        literal_operand,
                    ),
                ),
                pattern_span,
            );
            Some(Operand::Copy(Place::Local(matches_slot)))
        }
        ast::Pattern::Constructor {
            enum_name,
            variant,
            ..
        } => {
            // W12-jit-result-option-trinity (Phase 3 cluster-0 Round 7A,
            // 2026-05-12). For `Ok(v)` / `Err(e)` / `Some(x)` / `None`
            // patterns (per ADR-006 §2.7.17 / Q18 — kinded
            // `Arc<ResultData>` / `Arc<OptionData>` carrier), the
            // SwitchBool operand is NOT `Copy(scrutinee)` — that would
            // be a kind-blind I64 truthy check on the Arc<...> pointer
            // (always truthy → every arm takes the first branch). The
            // correct lowering emits an explicit `Rvalue::EnumTest {
            // operand, variant: <tag> }` into a fresh Bool slot, then
            // returns that slot as the SwitchBool operand. The JIT
            // consumer calls `jit_arc_result_is_ok` etc., reading the
            // discriminator field directly from the `*const ResultData`/
            // `*const OptionData` borrow per §2.7.17.
            //
            // Producer-site classification per §2.7.5; consumer dispatch
            // on `VariantTag` (no runtime tag-bit decode, §2.7.7 #4 / #7
            // forbidden).
            if let Some(tag) = VariantTag::from_name(variant) {
                let bool_slot = builder.alloc_temp(LocalTypeInfo::Copy);
                builder.push_stmt(
                    StatementKind::Assign(
                        Place::Local(bool_slot),
                        Rvalue::EnumTest {
                            operand: Operand::Copy(Place::Local(scrutinee_slot)),
                            variant: tag,
                        },
                    ),
                    pattern_span,
                );
                return Some(Operand::Copy(Place::Local(bool_slot)));
            }
            // W15.2-LANG-1 (Phase 4b, 2026-05-18). Non-trinity
            // constructor (user-defined enum variant — e.g. `Color::Red`).
            // Pre-fix this arm returned `Some(Operand::Copy(Place::Local(
            // scrutinee_slot)))` — the raw `Arc<TypedObjectStorage>`
            // pointer bits — as the SwitchBool condition. The JIT
            // consumer's generic I64-truthy path then evaluated the non-
            // zero pointer non-deterministically (silently empty output
            // for `match Color::Red { Color::Red => ..., Color::Green
            // => ..., Color::Blue => ... }`, book snippet
            // `enums.mdx:113`).
            //
            // Producer-side stamp-at-compile-time per ADR-006 §2.7.5:
            // the (enum_name, variant_name) pair is captured verbatim
            // into `Rvalue::EnumDiscriminantTest` so the consumer
            // dispatches on a known pair (not on raw bits, not on a
            // Bool-default fabrication). The JIT consumer's preflight
            // rejects this Rvalue today, routing the program through
            // the W12 fall-through to the bytecode interpreter (which
            // compiles `Pattern::Constructor` for user-defined enums
            // via the `compile_typed_enum_pattern_check` path in
            // `compiler/patterns/checking.rs` — emits
            // `GetFieldTyped(__variant, I64)` + `PushConst(variant_id)`
            // + `EqInt`).
            //
            // Mirrors the LANG-5 `TypePatternTest` precedent
            // (W15.2-LANG-5 close 2026-05-18).
            let bool_slot = builder.alloc_temp(LocalTypeInfo::Copy);
            builder.push_stmt(
                StatementKind::Assign(
                    Place::Local(bool_slot),
                    Rvalue::EnumDiscriminantTest {
                        operand: Operand::Copy(Place::Local(scrutinee_slot)),
                        enum_name: enum_name.as_ref().map(|p| p.as_str().to_string()),
                        variant_name: variant.clone(),
                    },
                ),
                pattern_span,
            );
            Some(Operand::Copy(Place::Local(bool_slot)))
        }
        ast::Pattern::Array(_) | ast::Pattern::Object(_) => {
            Some(Operand::Copy(Place::Local(scrutinee_slot)))
        }
    }
}

// ---------------------------------------------------------------------------
// Main expression dispatch
// ---------------------------------------------------------------------------

/// Lower an expression into a temporary slot.
///
/// This is the main expression dispatch: each `Expr` variant is matched and
/// lowered into one or more MIR statements, with the result placed into a
/// freshly-allocated temporary slot.
pub(crate) fn lower_expr_to_temp(builder: &mut MirBuilder, expr: &Expr) -> SlotId {
    let span = expr.span();
    let temp = builder.alloc_temp(LocalTypeInfo::Unknown);

    match expr {
        Expr::Literal(Literal::FormattedString { value, mode }, _) => {
            lower_formatted_string(builder, value, *mode, temp, span);
        }
        Expr::Literal(lit, _) => {
            let constant = match lit {
                Literal::Int(v) => MirConstant::Int(*v),
                Literal::UInt(v) => MirConstant::Int(*v as i64),
                Literal::TypedInt(v, _) => MirConstant::Int(*v),
                Literal::Number(v) => MirConstant::Float(f64::to_bits(*v)),
                // WS-8 (2026-05-22): preserve the decimal lexeme through MIR
                // instead of collapsing to Float(0). The pre-WS-8 collapse
                // silently lost the value, and the JIT printed `0.0` for
                // `print(1.5D)` (a v0.3-gating VM/JIT divergence per WS-8
                // audit §1.D). The JIT consumer surfaces-and-stops on this
                // variant (`compile_constant` returns Err), triggering the
                // W12 fall-through to the bytecode interpreter so the
                // program runs under VM (which materializes via
                // `NewDecimalV2` and prints correctly). VM == JIT.
                Literal::Decimal(d) => MirConstant::Decimal(d.to_string()),
                Literal::String(s) => MirConstant::Str(s.clone()),
                // Phase 3 cluster-2 Round 4 cw-D-fam12 follow-up (instance 57,
                // 2026-05-16). ADR-006 §2.7.5 amendment Round 19 S1.5: preserve
                // the Char kind through MIR lowering so the JIT's
                // `operand_slot_kind` / `infer_constant_kind` classifiers stamp
                // `NativeKind::Char` and the `print` dispatch routes to
                // `print_char(codepoint)` instead of `print_i64(codepoint)`.
                // Pre-fix divergence: `print('A')` → JIT prints "65", VM prints
                // "A". The pre-fix `MirConstant::Int(*c as i64)` was a
                // §2.7.5-violating producer-site kind-source loss.
                Literal::Char(c) => MirConstant::Char(*c),
                Literal::FormattedString { .. } => unreachable!("handled above"),
                Literal::Bool(v) => MirConstant::Bool(*v),
                Literal::None => MirConstant::None,
                Literal::Unit => MirConstant::Int(0), // unit is zero-sized
                Literal::Timeframe(_) => MirConstant::Int(0), // timeframe not yet modeled
            };
            builder.push_stmt(
                StatementKind::Assign(
                    Place::Local(temp),
                    Rvalue::Use(Operand::Constant(constant)),
                ),
                span,
            );
        }
        Expr::DataRef(_, _)
        | Expr::DataDateTimeRef(_, _)
        | Expr::TimeRef(_, _)
        | Expr::DateTime(_, _)
        | Expr::Duration(_, _)
        | Expr::Unit(_) => {
            builder.push_stmt(
                StatementKind::Assign(
                    Place::Local(temp),
                    Rvalue::Use(Operand::Constant(MirConstant::Int(0))),
                ),
                span,
            );
        }
        Expr::Identifier(name, _) => {
            // γ-CP7 jit-closure-param-fn-ref (2026-05-20): an
            // `Expr::Identifier` that does NOT resolve to a local slot is
            // a top-level function name used as a first-class value (e.g.
            // `apply(dbl)` where `dbl` is a `fn`, or `xs.sort(asc)`). The
            // bytecode compiler's `compile_expr_identifier`
            // (`compiler/expressions/identifiers.rs:423`) classifies this
            // via `find_function` and emits `Constant::Function(idx)`.
            // The MIR-lowering half previously fell through to
            // `MirConstant::None`, so the function-ref argument arrived at
            // the callee's closure-typed parameter slot as `0` — the JIT
            // indirect call (`jit_call_value`) then BAILed with a null
            // callee (`Ptr(HeapKind::Closure)` kind, bits=0) and the whole
            // method returned `TAG_NULL`. Mirror the bytecode classifier:
            // emit `MirConstant::Function(name)`, which the JIT resolves
            // through `function_indices` into the `box_function(fn_id)`
            // function-ref carrier. A name that is NOT a function (the
            // residual non-local-identifier shapes) still lowers to `0`
            // bits in `compile_constant` — identical to the prior `None`
            // behaviour, no regression.
            let operand = builder
                .lookup_local(name)
                .map(Place::Local)
                .map(Operand::Copy)
                .unwrap_or_else(|| Operand::Constant(MirConstant::Function(name.clone())));
            builder.record_task_boundary_operand(operand.clone());
            builder.push_stmt(
                StatementKind::Assign(Place::Local(temp), Rvalue::Use(operand)),
                span,
            );
        }
        Expr::PatternRef(name, _) => {
            // γ-CP7: mirror the `Expr::Identifier` arm — a non-local
            // `PatternRef` is likewise a function-name-as-value.
            let operand = builder
                .lookup_local(name)
                .map(Place::Local)
                .map(Operand::Copy)
                .unwrap_or_else(|| Operand::Constant(MirConstant::Function(name.clone())));
            builder.record_task_boundary_operand(operand.clone());
            builder.push_stmt(
                StatementKind::Assign(Place::Local(temp), Rvalue::Use(operand)),
                span,
            );
        }
        Expr::PropertyAccess { object, .. } => {
            if let Some(place) = lower_expr_to_place(builder, expr) {
                builder.record_task_boundary_operand(Operand::Copy(place.clone()));
                assign_copy_from_place(builder, temp, place, span);
            } else {
                lower_exprs_to_aggregate(builder, temp, [object.as_ref()], span);
            }
        }
        Expr::IndexAccess {
            object,
            index,
            end_index,
            ..
        } => {
            if let Some(place) = lower_expr_to_place(builder, expr) {
                builder.record_task_boundary_operand(Operand::Copy(place.clone()));
                assign_copy_from_place(builder, temp, place, span);
            } else {
                let mut operands = vec![
                    lower_expr_as_moved_operand(builder, object),
                    lower_expr_as_moved_operand(builder, index),
                ];
                if let Some(end_index) = end_index {
                    operands.push(lower_expr_as_moved_operand(builder, end_index));
                }
                builder.push_stmt(
                    StatementKind::Assign(Place::Local(temp), Rvalue::Aggregate(operands)),
                    span,
                );
            }
        }
        Expr::DataRelativeAccess { reference, .. } => {
            lower_exprs_to_aggregate(builder, temp, [reference.as_ref()], span);
        }
        Expr::Reference {
            expr: inner,
            is_mutable,
            span: ref_span,
        } => {
            let kind = if *is_mutable {
                BorrowKind::Exclusive
            } else {
                BorrowKind::Shared
            };
            let borrowed_place = if let Some(place) = lower_expr_to_place(builder, inner) {
                place
            } else {
                builder.mark_fallback();
                Place::Local(lower_expr_to_temp(builder, inner))
            };
            builder.push_stmt(
                StatementKind::Assign(
                    Place::Local(temp),
                    Rvalue::Borrow(kind, borrowed_place.clone()),
                ),
                *ref_span,
            );
            builder.record_task_boundary_reference_capture(temp, &borrowed_place);
        }
        Expr::UnaryOp { op, operand, .. } => {
            let operand = lower_expr_to_operand(builder, operand, false);
            if let Some(op) = lower_unary_op(*op) {
                builder.push_stmt(
                    StatementKind::Assign(Place::Local(temp), Rvalue::UnaryOp(op, operand)),
                    span,
                );
            } else {
                builder.push_stmt(
                    StatementKind::Assign(Place::Local(temp), Rvalue::Aggregate(vec![operand])),
                    span,
                );
            }
        }
        Expr::Assign(assign, _) => {
            let Some(target_place) = lower_assign_target_place(builder, &assign.target) else {
                builder.mark_fallback();
                assign_none(builder, temp, span);
                return temp;
            };
            let value_slot = lower_expr_to_temp(builder, &assign.value);
            builder.push_stmt(
                StatementKind::Assign(
                    target_place.clone(),
                    Rvalue::Use(Operand::Move(Place::Local(value_slot))),
                ),
                span,
            );
            builder.push_stmt(
                StatementKind::Assign(Place::Local(temp), Rvalue::Use(Operand::Copy(target_place))),
                span,
            );
        }
        Expr::Conditional {
            condition,
            then_expr,
            else_expr,
            ..
        } => {
            lower_conditional_expr(
                builder,
                condition,
                then_expr,
                else_expr.as_deref(),
                temp,
                span,
            );
        }
        Expr::If(if_expr, _) => {
            lower_conditional_expr(
                builder,
                &if_expr.condition,
                &if_expr.then_branch,
                if_expr.else_branch.as_deref(),
                temp,
                span,
            );
        }
        Expr::Block(block, _) => {
            lower_block_expr(builder, block, temp, span);
        }
        Expr::Let(let_expr, _) => {
            lower_let_expr(builder, let_expr, temp, span);
        }
        Expr::While(while_expr, _) => {
            lower_while_expr(builder, while_expr, temp, span);
        }
        Expr::For(for_expr, _) => {
            lower_for_expr(builder, for_expr, temp, span);
        }
        Expr::Loop(loop_expr, _) => {
            lower_loop_expr(builder, loop_expr, temp, span);
        }
        Expr::Match(match_expr, _) => {
            lower_match_expr(builder, match_expr, temp, span);
        }
        Expr::BinaryOp {
            left, op, right, ..
        } => {
            if *op == ast::BinaryOp::Pipe {
                lower_pipe_expr(builder, left, right, temp, span);
            } else if *op == ast::BinaryOp::NullCoalesce {
                lower_null_coalesce(builder, left, right, temp, span);
            } else if matches!(*op, ast::BinaryOp::And | ast::BinaryOp::Or) {
                // Phase 4b Round 5c-2-α jit-shortcircuit-eager soundness fix
                // (v0.3-gating per supervisor ratify 2026-05-19; sister-class
                // to LANG-9-spin-3-first) per ADR-006 §2.7.5 producer-side
                // stamp. Pre-fix MIR eagerly lowered both operands and
                // emitted `Rvalue::BinaryOp(BinOp::And|Or, l, r)`, which the
                // JIT then compiled as Cranelift `band`/`bor` — eager
                // bitwise, not short-circuit branches. The empirical t25
                // reproducer (W15.2-A close `7cbc316b`):
                // `side("a", true) || side("b", true)` printed `a\ntrue`
                // under VM vs `a\nb\ntrue` under JIT. Fix routes through
                // `SwitchBool` terminator (which JIT already compiles
                // correctly at `crates/shape-jit/src/mir_compiler/
                // terminators.rs:27-97`) — mirrors the bytecode VM compiler
                // pattern at `crates/shape-vm/src/compiler/expressions/
                // binary_ops.rs:723-754` and reuses the
                // `lower_null_coalesce` short-circuit template.
                lower_short_circuit_and_or(builder, left, *op, right, temp, span);
            } else {
                // ADR-006 §2.7.5 stamp-at-compile-time — u64-literal kind
                // inference. When one operand is a `u64`-typed expression
                // and the OTHER is a bare integer literal, lower the
                // literal directly as `Operand::Constant` instead of
                // hoisting it into a `Copy(Local)` temp. The JIT's
                // `uint64_binop_site` classifier recognizes a direct
                // `Operand::Constant(MirConstant::Int(_))` sibling as a
                // width-polymorphic literal that adopts the `u64` width —
                // a hoisted temp is not recognized (its slot kind is the
                // width-blind `Int64`). The u64-ness is captured BEFORE
                // lowering since `lower_expr_to_operand` mutates the
                // builder.
                let left_is_u64 = expr_is_u64_typed(builder, left);
                let right_is_u64 = expr_is_u64_typed(builder, right);
                let l = if right_is_u64 {
                    lower_int_literal_as_direct_constant(left)
                        .unwrap_or_else(|| lower_expr_to_operand(builder, left, false))
                } else {
                    lower_expr_to_operand(builder, left, false)
                };
                let r = if left_is_u64 {
                    lower_int_literal_as_direct_constant(right)
                        .unwrap_or_else(|| lower_expr_to_operand(builder, right, false))
                } else {
                    lower_expr_to_operand(builder, right, false)
                };
                if let Some(op) = lower_binary_op(*op) {
                    builder.push_stmt(
                        StatementKind::Assign(Place::Local(temp), Rvalue::BinaryOp(op, l, r)),
                        span,
                    );
                } else {
                    builder.push_stmt(
                        StatementKind::Assign(Place::Local(temp), Rvalue::Aggregate(vec![l, r])),
                        span,
                    );
                }
            }
        }
        Expr::FuzzyComparison {
            left, op, right, ..
        } => {
            let l = lower_expr_to_operand(builder, left, false);
            let r = lower_expr_to_operand(builder, right, false);
            let mir_op = match op {
                ast::operators::FuzzyOp::Equal => BinOp::Eq,
                ast::operators::FuzzyOp::Greater => BinOp::Gt,
                ast::operators::FuzzyOp::Less => BinOp::Lt,
            };
            builder.push_stmt(
                StatementKind::Assign(Place::Local(temp), Rvalue::BinaryOp(mir_op, l, r)),
                span,
            );
        }
        Expr::Break(value, _) => {
            super::stmt::lower_break_control_flow(builder, value.as_deref(), span);
            assign_none(builder, temp, span);
        }
        Expr::Continue(_) => {
            super::stmt::lower_continue_control_flow(builder, span);
            assign_none(builder, temp, span);
        }
        Expr::Return(value, _) => {
            super::stmt::lower_return_control_flow(builder, value.as_deref(), span);
            assign_none(builder, temp, span);
        }
        Expr::FunctionCall {
            name,
            args,
            named_args,
            ..
        } => {
            // W12-enum-constructor-mir-lowering (Phase 3 cluster-0 Round 4,
            // 2026-05-12 audit `588fba2c`): bare-form enum-variant
            // constructors (`Ok(x)` / `Err(x)` / `Some(x)`) parse as
            // `Expr::FunctionCall { name: "Ok", ... }` but are NOT
            // function calls — the VM dispatches them via
            // `OpCode::BuiltinCall(OkCtor)` etc., not via the function
            // table. The pre-fix MIR shape emitted
            // `Call { func: Constant(Function("Ok")), ... }`, which the
            // JIT's `compile_constant` could not resolve (no entry in
            // `function_indices`); it fell back to `iconst(I64, 0)`,
            // the indirect-call dispatched with `callee_bits=0`, and
            // downstream code segfaulted on TAG_NULL.
            //
            // Per ADR-006 §2.7.5 producing-site classification, the
            // constructor's kind is known here at MIR-emit time: the
            // name resolves through the same classifier the bytecode
            // compiler uses (`classify_builtin_function` at
            // `compiler/helpers.rs:3194-3209`). The rewrite lowers
            // the bare form to the same `Aggregate` + `EnumStore` MIR
            // shape the qualified `Result::Ok(x)` path already uses
            // (see `Expr::EnumConstructor` arm below) — preserving
            // ADR-006 §2.7.27 mutation-writeback's container-kind
            // classification at the producing site, and matching the
            // VM-side bytecode compiler's interception of these names
            // at `compile_expr_function_call`
            // (`compiler/expressions/function_calls.rs:870-971`).
            //
            // The intercept happens AFTER local-shadow resolution
            // (`builder.lookup_local(name)`) so user code that
            // rebinds `let Ok = ...; Ok(5)` still calls the local.
            if builder.lookup_local(name).is_none()
                && is_bare_enum_variant_ctor(name)
                && named_args.is_empty()
            {
                let operands: Vec<_> = args
                    .iter()
                    .map(|arg| lower_expr_as_moved_operand(builder, arg))
                    .collect();
                builder.push_stmt(
                    StatementKind::Assign(
                        Place::Local(temp),
                        Rvalue::Aggregate(operands.clone()),
                    ),
                    span,
                );
                // ADR-006 §2.7.5 — thread the variant name into EnumStore
                // so the JIT consumer (`crates/shape-jit/src/mir_compiler/
                // statements.rs::EnumStore`) can dispatch to
                // `jit_v2_make_result_ok` / `_err` / `jit_v2_make_option_some`.
                // The W12-jit-aggregate-non-array fix.
                emit_container_store_full(
                    builder,
                    ContainerStoreKind::Enum,
                    temp,
                    operands,
                    Vec::new(),
                    Some(name.clone()),
                    span,
                );
                return temp;
            }

            // W12-collection-constructor-mir-lowering (Phase 3 cluster-0
            // Round 6C, 2026-05-12): bare-form primitive-collection
            // constructors (`Set()` / `HashMap()` / `Deque()` /
            // `PriorityQueue()` / `Channel()` / `Mutex(x)` / `Atomic(x)`
            // / `Lazy(x)`) parse as `Expr::FunctionCall { name: "Set",
            // ... }` but are NOT function calls — the VM dispatches them
            // via `OpCode::BuiltinCall(SetCtor / HashMapCtor / ...)`,
            // not via the function table. Pre-fix MIR emitted
            // `Call { func: Constant(Function("Set")), ... }`, the JIT's
            // `compile_constant` could not resolve the name through
            // `function_indices`, fell back to `iconst(I64, 0)`, and
            // downstream code received `callee_bits = 0` → garbage
            // values silently propagated through `.add()` / `.size()`
            // method dispatch (the §2.1 enum-variant family produced a
            // segfault chain at this point; here it's a silent-wrong-
            // answer because the PHF method dispatch reads null bits as
            // a valid Arc rather than crashing).
            //
            // Per ADR-006 §2.7.5 producing-site classification, the
            // constructor's kind is known here at MIR-emit time. The
            // rewrite reuses the same `Aggregate` + `EnumStore` MIR
            // shape as the bare-form enum-variant family (the audit's
            // §5.3 "simpler alternative — reuse `EnumStore` with
            // `kind`-on-the-slot threading" recommendation), with the
            // collection name threaded via `variant_name`. The JIT
            // EnumStore consumer disambiguates enum-ctor from
            // collection-ctor by name and surfaces a collection-ctor-
            // specific §-cited message (no garbage propagation,
            // honest surface-and-stop equivalence ratchet per the
            // W12-enum-constructor close pattern).
            //
            // The intercept happens AFTER local-shadow resolution so
            // user code that rebinds `let Set = ...; Set(5)` still
            // calls the local. `named_args.is_empty()` preserves the
            // legacy named-args error path.
            //
            // Site 1 of 3: `Expr::FunctionCall` direct call.
            if builder.lookup_local(name).is_none()
                && is_bare_collection_ctor(name)
                && named_args.is_empty()
            {
                let operands: Vec<_> = args
                    .iter()
                    .map(|arg| lower_expr_as_moved_operand(builder, arg))
                    .collect();
                emit_collection_ctor_store(builder, temp, operands, name.clone(), span);
                return temp;
            }

            let mut arg_ops = Vec::with_capacity(args.len() + named_args.len());
            arg_ops.extend(
                args.iter()
                    .map(|arg| lower_expr_as_moved_operand(builder, arg)),
            );
            arg_ops.extend(
                named_args
                    .iter()
                    .map(|(_, expr)| lower_expr_as_moved_operand(builder, expr)),
            );
            let func_op = if let Some(slot) = builder.lookup_local(name) {
                Operand::Copy(Place::Local(slot))
            } else {
                Operand::Constant(MirConstant::Function(name.clone()))
            };
            builder.emit_call(func_op, arg_ops, Place::Local(temp), span);
        }
        Expr::QualifiedFunctionCall {
            namespace,
            function,
            args,
            named_args,
            ..
        } => {
            let mut arg_ops = Vec::with_capacity(args.len() + named_args.len());
            arg_ops.extend(
                args.iter()
                    .map(|arg| lower_expr_as_moved_operand(builder, arg)),
            );
            arg_ops.extend(
                named_args
                    .iter()
                    .map(|(_, expr)| lower_expr_as_moved_operand(builder, expr)),
            );
            let func_op = Operand::Constant(MirConstant::Function(format!(
                "{}::{}",
                namespace, function
            )));
            builder.emit_call(func_op, arg_ops, Place::Local(temp), span);
        }
        Expr::EnumConstructor { variant, payload, .. } => match payload {
            ast::EnumConstructorPayload::Unit => {
                assign_none(builder, temp, span);
            }
            ast::EnumConstructorPayload::Tuple(values) => {
                let operands: Vec<_> = values
                    .iter()
                    .map(|expr| lower_expr_as_moved_operand(builder, expr))
                    .collect();
                builder.push_stmt(
                    StatementKind::Assign(Place::Local(temp), Rvalue::Aggregate(operands.clone())),
                    span,
                );
                // ADR-006 §2.7.5 — thread the variant name into EnumStore
                // so the JIT EnumStore consumer can dispatch to the right
                // typed-Arc producer (W12-jit-aggregate-non-array).
                emit_container_store_full(
                    builder,
                    ContainerStoreKind::Enum,
                    temp,
                    operands,
                    Vec::new(),
                    Some(variant.clone()),
                    span,
                );
            }
            ast::EnumConstructorPayload::Struct(fields) => {
                let operands: Vec<_> = fields
                    .iter()
                    .map(|(_, expr)| lower_expr_as_moved_operand(builder, expr))
                    .collect();
                builder.push_stmt(
                    StatementKind::Assign(Place::Local(temp), Rvalue::Aggregate(operands.clone())),
                    span,
                );
                emit_container_store_full(
                    builder,
                    ContainerStoreKind::Enum,
                    temp,
                    operands,
                    Vec::new(),
                    Some(variant.clone()),
                    span,
                );
            }
        },
        Expr::Object(entries, _) => {
            let mut operands = Vec::new();
            let mut field_names = Vec::new();
            for entry in entries {
                match entry {
                    ast::ObjectEntry::Field { key, value, .. } => {
                        operands.push(lower_expr_as_moved_operand(builder, value));
                        field_names.push(key.clone());
                    }
                    ast::ObjectEntry::Spread(expr) => {
                        operands.push(lower_expr_as_moved_operand(builder, expr));
                        // Spread entries don't have a single key — use empty string as marker
                        field_names.push(String::new());
                    }
                }
            }
            builder.push_stmt(
                StatementKind::Assign(Place::Local(temp), Rvalue::Aggregate(operands.clone())),
                span,
            );
            emit_container_store_with_names(
                builder,
                ContainerStoreKind::Object,
                temp,
                operands,
                field_names,
                span,
            );
        }
        Expr::Array(elements, _) => {
            lower_array_expr(builder, elements, temp, span);
        }
        Expr::ListComprehension(comp, _) => {
            lower_list_comprehension_expr(builder, comp, temp, span);
        }
        Expr::TypeAssertion {
            expr,
            type_annotation,
            meta_param_overrides,
            ..
        } => {
            lower_type_assertion_expr(builder, expr, type_annotation, meta_param_overrides, temp, span
            );
        }
        Expr::InstanceOf { expr, .. } => {
            lower_exprs_to_aggregate(builder, temp, [expr.as_ref()], span);
        }
        Expr::FunctionExpr { params, body, .. } => {
            lower_function_expr(builder, params, body, temp, span);
        }
        Expr::Spread(expr, _) => {
            let expr_slot = lower_expr_to_temp(builder, expr);
            assign_copy_from_slot(builder, temp, expr_slot, span);
        }
        Expr::MethodCall {
            receiver,
            method,
            args,
            named_args,
            ..
        } => {
            // Phase 4b Round 4 Surface-1a LANG-W13-3-iife-closure-capture
            // JIT residual fix (2026-05-18). The bytecode compiler at
            // `compiler/expressions/function_calls.rs:1832` already
            // intercepts `MethodCall { method: "__call__" }` (the
            // parser shape for IIFE / chained call `f(a)(b)`) and
            // emits `CallValue` directly with the receiver as the
            // callee on the stack — the VM's `op_call_value` then
            // dispatches through `call_value_immediate_nb` per the
            // §2.7.11/Q12 callee-kind classification. Mirror that
            // producer-side classification here at the MIR lowering
            // site per ADR-006 §2.7.5 stamp-at-compile-time: lower the
            // receiver as the `func` operand and the user args as
            // `arg_ops` directly (no `MirConstant::Method("__call__")`
            // method-name carrier). The JIT terminator's indirect-call
            // path at `mir_compiler/terminators.rs:1486` then sources
            // the callee kind via `operand_slot_kind_or_carrier(func)`
            // — for an IIFE-emitted closure slot stamped
            // `Ptr(HeapKind::Closure)` per the §2.7.11/Q12 ClosureCapture
            // arm in `infer_slot_kinds`, this routes through
            // `jit_call_value`'s closure-arm dispatch correctly. Pre-fix
            // the MIR carried `Method("__call__")` to the JIT which
            // routed through `jit_call_method` — that shell's
            // `Ptr(HeapKind::Closure)` receiver-kind arm at
            // `ffi/call_method/mod.rs:801` returns `TAG_NULL`
            // unconditionally (no `__call__` builtin for closure
            // receivers), surfacing as the `0xfffb_0000_0000_0000`
            // garbage at the assignment-to-`let mut` destination.
            if method == "__call__" {
                let func_op = lower_expr_as_moved_operand(builder, receiver);
                let mut arg_ops = Vec::with_capacity(args.len() + named_args.len());
                arg_ops.extend(
                    args.iter()
                        .map(|arg| lower_expr_as_moved_operand(builder, arg)),
                );
                arg_ops.extend(
                    named_args
                        .iter()
                        .map(|(_, expr)| lower_expr_as_moved_operand(builder, expr)),
                );
                builder.emit_call(func_op, arg_ops, Place::Local(temp), span);
                return temp;
            }
            let receiver_op = lower_expr_as_moved_operand(builder, receiver);
            let mut arg_ops = Vec::with_capacity(1 + args.len() + named_args.len());
            arg_ops.push(receiver_op);
            arg_ops.extend(
                args.iter()
                    .map(|arg| lower_expr_as_moved_operand(builder, arg)),
            );
            arg_ops.extend(
                named_args
                    .iter()
                    .map(|(_, expr)| lower_expr_as_moved_operand(builder, expr)),
            );
            let func_op = Operand::Constant(MirConstant::Method(method.clone()));
            builder.emit_call(func_op, arg_ops, Place::Local(temp), span);
            emit_mut_self_writeback_if_needed(builder, receiver, method, temp, span);
        }
        Expr::Range { start, end, .. } => {
            let mut operands = Vec::new();
            if let Some(start) = start {
                operands.push(lower_expr_as_moved_operand(builder, start));
            }
            if let Some(end) = end {
                operands.push(lower_expr_as_moved_operand(builder, end));
            }
            builder.push_stmt(
                StatementKind::Assign(Place::Local(temp), Rvalue::Aggregate(operands)),
                span,
            );
        }
        Expr::TimeframeContext { expr, .. }
        | Expr::TryOperator(expr, _)
        | Expr::UsingImpl { expr, .. } => {
            let expr_slot = lower_expr_to_temp(builder, expr);
            assign_copy_from_slot(builder, temp, expr_slot, span);
        }
        Expr::SimulationCall { params, .. } => {
            lower_exprs_to_aggregate(builder, temp, params.iter().map(|(_, expr)| expr), span);
        }
        Expr::StructLiteral {
            type_name, fields, ..
        } => {
            let operands: Vec<_> = fields
                .iter()
                .map(|(_, expr)| lower_expr_as_moved_operand(builder, expr))
                .collect();
            let field_names: Vec<_> = fields
                .iter()
                .map(|(name, _)| name.clone())
                .collect();
            builder.push_stmt(
                StatementKind::Assign(Place::Local(temp), Rvalue::Aggregate(operands.clone())),
                span,
            );
            emit_container_store_with_names(
                builder,
                ContainerStoreKind::Object,
                temp,
                operands,
                field_names,
                span,
            );
            // ADR-006 §2.7.5 producing-site classification — Phase 3
            // cluster-0 Round 13 T1' gap 1 closure. Record the struct
            // type name on the destination slot so the conduit
            // producer (and downstream JIT trait-method return-kind
            // classifier) can map receiver-slot → struct-type-name →
            // trait method declared return ConcreteType for
            // `t.method()`-style call terminators.
            builder.record_local_struct_type_name(temp, type_name.name().to_string());
        }
        Expr::Annotated {
            annotation, target, ..
        } => {
            let mut operands = Vec::with_capacity(annotation.args.len() + 1);
            operands.extend(
                annotation
                    .args
                    .iter()
                    .map(|expr| lower_expr_as_moved_operand(builder, expr)),
            );
            operands.push(lower_expr_as_moved_operand(builder, target));
            builder.push_stmt(
                StatementKind::Assign(Place::Local(temp), Rvalue::Aggregate(operands)),
                span,
            );
        }
        Expr::TableRows(rows, _) => {
            let mut operands = Vec::new();
            for row in rows {
                operands.extend(
                    row.iter()
                        .map(|expr| lower_expr_as_moved_operand(builder, expr)),
                );
            }
            builder.push_stmt(
                StatementKind::Assign(Place::Local(temp), Rvalue::Aggregate(operands)),
                span,
            );
        }
        Expr::Await(inner, _) => {
            lower_await_expr(builder, inner, temp, span);
        }
        Expr::Join(join_expr, _) => {
            lower_join_expr(builder, join_expr, temp, span);
        }
        Expr::AsyncLet(async_let, _) => {
            lower_async_let_expr(builder, async_let, temp, span);
        }
        Expr::AsyncScope(inner, _) => {
            lower_async_scope_expr(builder, inner, temp, span);
        }
        Expr::FromQuery(from_query, _) => {
            lower_from_query_expr(builder, from_query, temp, span);
        }
        Expr::Comptime(stmts, _) => {
            lower_comptime_expr(builder, stmts, temp, span);
        }
        Expr::ComptimeFor(comptime_for, _) => {
            lower_comptime_for_expr(builder, comptime_for, temp, span);
        }
        Expr::WindowExpr(window_expr, _) => {
            // Lower window expressions as an aggregate of their sub-expressions.
            // The borrow solver only needs to track which slots are read.
            let mut operands = Vec::new();
            lower_window_function_operands(builder, &window_expr.function, &mut operands);
            for expr in &window_expr.over.partition_by {
                operands.push(lower_expr_as_moved_operand(builder, expr));
            }
            if let Some(order_by) = &window_expr.over.order_by {
                for (expr, _) in &order_by.columns {
                    operands.push(lower_expr_as_moved_operand(builder, expr));
                }
            }
            builder.push_stmt(
                StatementKind::Assign(Place::Local(temp), Rvalue::Aggregate(operands)),
                span,
            );
        }
    }

    temp
}

// ---------------------------------------------------------------------------
// Pipe operator lowering
// ---------------------------------------------------------------------------

fn lower_pipe_expr(
    builder: &mut MirBuilder,
    left: &Expr,
    right: &Expr,
    temp: SlotId,
    span: Span,
) {
    match right {
        Expr::FunctionCall {
            name,
            args,
            named_args,
            ..
        } => {
            // W12-enum-constructor-mir-lowering: same producer-side
            // classification as the non-piped path above. `expr |> Ok`
            // is a constructor expression, not a function call.
            if builder.lookup_local(name).is_none()
                && is_bare_enum_variant_ctor(name)
                && named_args.is_empty()
            {
                let left_op = lower_expr_as_moved_operand(builder, left);
                let mut operands = Vec::with_capacity(1 + args.len());
                operands.push(left_op);
                operands.extend(
                    args.iter()
                        .map(|arg| lower_expr_as_moved_operand(builder, arg)),
                );
                builder.push_stmt(
                    StatementKind::Assign(
                        Place::Local(temp),
                        Rvalue::Aggregate(operands.clone()),
                    ),
                    span,
                );
                emit_container_store_full(
                    builder,
                    ContainerStoreKind::Enum,
                    temp,
                    operands,
                    Vec::new(),
                    Some(name.clone()),
                    span,
                );
                return;
            }

            // W12-collection-constructor-mir-lowering: Site 2 of 3 —
            // pipe-operator `FunctionCall` form (`x |> Mutex(...)`).
            // Only meaningful for the with-arg subset
            // (`Mutex`/`Atomic`/`Lazy`); zero-arg ctors via pipe
            // (`x |> Set()`) fall through to the legacy `Call` path
            // since `Set` rejects positional args at the VM-side
            // ctor body — matching the bytecode-compile-time error
            // shape rather than silently discarding the piped value.
            if builder.lookup_local(name).is_none()
                && is_bare_collection_ctor_with_arg(name)
                && named_args.is_empty()
            {
                let left_op = lower_expr_as_moved_operand(builder, left);
                let mut operands = Vec::with_capacity(1 + args.len());
                operands.push(left_op);
                operands.extend(
                    args.iter()
                        .map(|arg| lower_expr_as_moved_operand(builder, arg)),
                );
                emit_collection_ctor_store(builder, temp, operands, name.clone(), span);
                return;
            }

            let left_op = lower_expr_as_moved_operand(builder, left);
            let mut arg_ops = Vec::with_capacity(1 + args.len() + named_args.len());
            arg_ops.push(left_op);
            arg_ops.extend(args.iter().map(|arg| lower_expr_as_moved_operand(builder, arg)));
            arg_ops.extend(named_args.iter().map(|(_, expr)| lower_expr_as_moved_operand(builder, expr)));
            let func_op = Operand::Constant(MirConstant::Function(name.clone()));
            builder.emit_call(func_op, arg_ops, Place::Local(temp), span);
        }
        Expr::MethodCall {
            receiver,
            method,
            args,
            named_args,
            ..
        } => {
            let receiver_op = lower_expr_as_moved_operand(builder, receiver);
            let left_op = lower_expr_as_moved_operand(builder, left);
            let mut arg_ops = Vec::with_capacity(2 + args.len() + named_args.len());
            arg_ops.push(receiver_op);
            arg_ops.push(left_op);
            arg_ops.extend(args.iter().map(|arg| lower_expr_as_moved_operand(builder, arg)));
            arg_ops.extend(named_args.iter().map(|(_, expr)| lower_expr_as_moved_operand(builder, expr)));
            let func_op = Operand::Constant(MirConstant::Method(method.clone()));
            builder.emit_call(func_op, arg_ops, Place::Local(temp), span);
            emit_mut_self_writeback_if_needed(builder, receiver, method, temp, span);
        }
        Expr::Identifier(name, _) => {
            // W12-collection-constructor-mir-lowering: Site 3 of 3 —
            // pipe-operator `Identifier` form (`x |> Mutex`). Only
            // meaningful for the with-arg subset (Mutex/Atomic/Lazy);
            // for zero-arg ctors (`x |> Set`) the piped value has
            // nowhere to go — fall through to the legacy `Call` path,
            // which surfaces the existing function-table lookup miss
            // (the bare-Identifier-callee form is rare enough that
            // CLAUDE.md doesn't track it as a load-bearing failure
            // mode). Apply intercept BEFORE the enum-variant intercept
            // since `Mutex`/`Atomic`/`Lazy` and `Ok`/`Err`/`Some` are
            // disjoint sets.
            if builder.lookup_local(name).is_none()
                && is_bare_collection_ctor_with_arg(name)
            {
                let left_op = lower_expr_as_moved_operand(builder, left);
                let operands = vec![left_op];
                emit_collection_ctor_store(builder, temp, operands, name.clone(), span);
                return;
            }
            // W12-enum-constructor-mir-lowering: `expr |> Ok` form —
            // pipe into a bare-form constructor ident. Same producer-
            // side classification.
            if builder.lookup_local(name).is_none() && is_bare_enum_variant_ctor(name) {
                let left_op = lower_expr_as_moved_operand(builder, left);
                let operands = vec![left_op];
                builder.push_stmt(
                    StatementKind::Assign(
                        Place::Local(temp),
                        Rvalue::Aggregate(operands.clone()),
                    ),
                    span,
                );
                emit_container_store_full(
                    builder,
                    ContainerStoreKind::Enum,
                    temp,
                    operands,
                    Vec::new(),
                    Some(name.clone()),
                    span,
                );
                return;
            }
            let left_op = lower_expr_as_moved_operand(builder, left);
            let func_op = Operand::Constant(MirConstant::Function(name.clone()));
            builder.emit_call(func_op, vec![left_op], Place::Local(temp), span);
        }
        _ => {
            let l = lower_expr_to_operand(builder, left, false);
            let r = lower_expr_to_operand(builder, right, false);
            builder.push_stmt(
                StatementKind::Assign(Place::Local(temp), Rvalue::Aggregate(vec![l, r])),
                span,
            );
        }
    }
}

// ---------------------------------------------------------------------------
// Type assertion lowering
// ---------------------------------------------------------------------------

fn lower_type_assertion_expr(
    builder: &mut MirBuilder,
    expr: &Expr,
    type_annotation: &ast::TypeAnnotation,
    meta_param_overrides: &Option<std::collections::HashMap<String, Expr>>,
    temp: SlotId,
    span: Span,
) {
    // For primitive target types, emit a Call to the specific Into trait
    // implementation. We don't know the source type at MIR lowering time,
    // but the JIT's method dispatch for "into" resolves based on value type.
    // However, method dispatch doesn't know the TARGET type.
    //
    // Alternative approach: use the bytecode compiler's ConvertTo* pattern.
    // The `jit_call_method` handler for "into" doesn't exist, so instead
    // we emit a method call that includes the target type name, which the
    // JIT method dispatch can use for conversion.
    // Use method dispatch for type conversion. The JIT method handler
    // resolves "into" on values — for int.into() it returns number, etc.
    // We use type-specific method names that exist in the method registry.
    let conversion_method = match type_annotation {
        ast::TypeAnnotation::Basic(name) => match name.as_str() {
            // "toNumber" exists on int, bool, string via method registry
            "number" => Some("toNumber"),
            // "toString" exists on all types via method registry
            "string" => Some("toString"),
            // For "int": no universal "toInt" method. Use the Into function directly.
            // The compiled Into::number::int::into is a regular function.
            "int" => None, // handled below as Into function call
            "bool" => Some("toBool"),
            _ => None,
        },
        _ => None,
    };

    if let Some(method_name) = conversion_method {
        let arg = lower_expr_as_moved_operand(builder, expr);
        let func_op = Operand::Constant(MirConstant::Method(method_name.to_string()));
        builder.emit_call(func_op, vec![arg], Place::Local(temp), span);
    } else if matches!(type_annotation, ast::TypeAnnotation::Basic(n) if n == "int") {
        // For "as int": emit BinaryOp with a floor-style conversion.
        // Multiplying by 1 triggers the generic_mul FFI which handles
        // number*int → int conversion. But a cleaner approach:
        // just call the function directly by trying all Into variants.
        // The simplest: use BinaryOp::Mul with 1 which coerces to int in the VM.
        // Actually, the cleanest: use a special Or with 0 (bitwise) which is identity for ints.
        // For now, use Aggregate (the value passes through unchanged, and the executor
        // reads the NaN-boxed type tag to marshal correctly).
        let arg = lower_expr_as_moved_operand(builder, expr);
        // Emit: result = arg | 0  (bitwise OR with 0 is identity but triggers int coercion)
        // Actually simpler: just pass through. The value is already the right bits,
        // the executor's return marshaling handles the type interpretation.
        builder.push_stmt(
            StatementKind::Assign(Place::Local(temp), Rvalue::Use(arg)),
            span,
        );
    } else {
        let mut operands = vec![lower_expr_as_moved_operand(builder, expr)];
        if let Some(overrides) = meta_param_overrides {
            let mut keys: Vec<_> = overrides.keys().cloned().collect();
            keys.sort();
            for key in keys {
                if let Some(value) = overrides.get(&key) {
                    operands.push(lower_expr_as_moved_operand(builder, value));
                }
            }
        }
        builder.push_stmt(
            StatementKind::Assign(Place::Local(temp), Rvalue::Aggregate(operands)),
            span,
        );
    }
}