aver-lang 0.22.1

use super::builtins;
use super::emit_ctx::{EmitCtx, expr_can_move, expr_skip_clone, should_borrow_param};
use super::pattern::emit_pattern;
use crate::ast::{BinOp, Literal, Spanned, TypeDef};
use crate::codegen::CodegenContext;
use crate::codegen::common::{module_prefix_to_rust_path, resolve_module_call};
use crate::ir::hir::{
    BuiltinIntrinsic, ResolvedBodyExprPlan, ResolvedBodyPlan, ResolvedBoolSubjectPlan,
    ResolvedCallee, ResolvedCtor, ResolvedExpr, ResolvedFnDef, ResolvedLeafOp, ResolvedMatchArm,
    ResolvedPattern, ResolvedStmt, ResolvedThinBodyPlan, ThinKind, call_plan_from_resolved_callee,
    classify_body_expr_plan_resolved, classify_body_plan_resolved,
    classify_bool_subject_plan_resolved, classify_leaf_op_resolved,
    classify_list_match_shape_resolved, classify_match_dispatch_plan_resolved,
    classify_thin_fn_def_resolved, resolved_to_dotted, semantic_constructor_from_resolved_ctor,
};
use crate::ir::vars::resolved_pattern_bindings;
use crate::ir::{
    BoolCompareOp, CallPlan, DispatchArmPlan, DispatchBindingPlan, DispatchDefaultPlan,
    DispatchLiteral, DispatchTableShape, ListMatchShape, MatchDispatchPlan, SemanticConstructor,
    SemanticDispatchPattern, WrapperKind,
};
use crate::types::{self, Type};
/// Aver expressions → Rust expression strings.
use std::collections::HashSet;

pub use super::syntax::{aver_name_to_rust, emit_stmt};
pub(super) use super::syntax::{has_list_patterns, has_string_literal_patterns};

/// Predicate adapter shared by every resolved-shape classifier — the
/// shared classifiers don't know about [`CodegenContext`] (it lives in
/// the codegen crate, classifiers live in the IR), so they take a
/// `Fn(&str) -> bool` for user-type recognition.
fn is_user_type_fn(ctx: &CodegenContext) -> impl Fn(&str) -> bool + '_ {
    move |name: &str| crate::codegen::common::is_user_type(name, ctx)
}

pub(super) fn classify_dispatch_plan_for_rust(
    arms: &[ResolvedMatchArm],
    _ctx: &CodegenContext,
    _ectx: &EmitCtx,
) -> Option<MatchDispatchPlan> {
    classify_match_dispatch_plan_resolved(arms)
}

pub(super) fn classify_body_plan_for_rust<'a>(
    body: &'a crate::ir::hir::ResolvedFnBody,
    ctx: &CodegenContext,
    _ectx: &EmitCtx,
) -> Option<ResolvedBodyPlan<'a>> {
    classify_body_plan_resolved(body, &is_user_type_fn(ctx))
}

#[allow(dead_code)]
pub(super) fn classify_body_expr_plan_for_rust<'a>(
    expr: &'a ResolvedExpr,
    ctx: &CodegenContext,
    _ectx: &EmitCtx,
) -> ResolvedBodyExprPlan<'a> {
    classify_body_expr_plan_resolved(expr, &is_user_type_fn(ctx))
}

pub(super) fn classify_thin_fn_def_for_rust<'a>(
    fd: &'a ResolvedFnDef,
    ctx: &'a CodegenContext,
    _ectx: &'a EmitCtx,
) -> Option<ResolvedThinBodyPlan<'a>> {
    classify_thin_fn_def_resolved(fd, &is_user_type_fn(ctx))
}

/// Emit a Rust expression from a resolved Aver Expr.
pub fn emit_expr(expr: &ResolvedExpr, ctx: &CodegenContext, ectx: &EmitCtx) -> String {
    emit_expr_with_options(expr, ctx, ectx, true)
}

fn emit_tuple_from_vars(prefix: &str, count: usize) -> String {
    match count {
        0 => "()".to_string(),
        1 => format!("({prefix}0,)"),
        _ => format!(
            "({})",
            (0..count)
                .map(|i| format!("{prefix}{i}"))
                .collect::<Vec<_>>()
                .join(", ")
        ),
    }
}

fn emit_result_tuple_unwrap(result_prefix: &str, value_prefix: &str, count: usize) -> String {
    let matched_results = emit_tuple_from_vars(result_prefix, count);
    let ok_pattern = match count {
        0 => "()".to_string(),
        1 => format!("(Ok({value_prefix}0),)"),
        _ => format!(
            "({})",
            (0..count)
                .map(|i| format!("Ok({value_prefix}{i})"))
                .collect::<Vec<_>>()
                .join(", ")
        ),
    };
    let ok_tuple = emit_tuple_from_vars(value_prefix, count);

    let mut out = format!(
        "match {} {{ {} => Ok({}), {} => {{ ",
        matched_results, ok_pattern, ok_tuple, matched_results
    );
    for i in 0..count {
        out.push_str(&format!(
            "if let Err(__err) = {result_prefix}{i} {{ Err(__err) }} else "
        ));
    }
    out.push_str("{ unreachable!(\"independent product unwrap requires Result branches\") } } }");
    out
}

fn emit_parallel_result_tuple_unwrap(
    branch_prefix: &str,
    result_prefix: &str,
    value_prefix: &str,
    count: usize,
) -> String {
    let matched_branches = emit_tuple_from_vars(branch_prefix, count);
    let completed_pattern = match count {
        0 => "()".to_string(),
        1 => format!("(crate::ParallelBranch::Completed({result_prefix}0),)"),
        _ => format!(
            "({})",
            (0..count)
                .map(|i| format!("crate::ParallelBranch::Completed({result_prefix}{i})"))
                .collect::<Vec<_>>()
                .join(", ")
        ),
    };

    let mut out = format!(
        "match {} {{ {} => {}, {} => {{ ",
        matched_branches,
        completed_pattern,
        emit_result_tuple_unwrap(result_prefix, value_prefix, count),
        matched_branches
    );
    for i in 0..count {
        out.push_str(&format!(
            "if let crate::ParallelBranch::Completed(Err(__err)) = {branch_prefix}{i} {{ Err(__err) }} else "
        ));
    }
    out.push_str("{ panic!(\"independent product branch cancelled by sibling branch\") } } }");
    out
}

fn emit_expr_with_options(
    expr: &ResolvedExpr,
    ctx: &CodegenContext,
    ectx: &EmitCtx,
    allow_callsite_inlining: bool,
) -> String {
    if let Some(leaf) = classify_leaf_op_resolved(expr, &is_user_type_fn(ctx)) {
        return emit_leaf_op_with_options(&leaf, ctx, ectx, allow_callsite_inlining);
    }

    match expr {
        ResolvedExpr::Literal(lit) => emit_literal(lit),
        ResolvedExpr::Ident(name) | ResolvedExpr::Resolved { name, .. } => aver_name_to_rust(name),
        ResolvedExpr::Attr(_, _) => unreachable!(
            "ResolvedExpr::Attr must be lowered through classify_leaf_op_resolved (field access, \
             None, variant constructor, or static ref); reaching this arm means \
             classify_field_access returned None for an Attr shape — a bug in ir::hir::classify"
        ),
        ResolvedExpr::Call(callee, args) => {
            emit_fn_call_with_options(callee, args, ctx, ectx, allow_callsite_inlining)
        }
        ResolvedExpr::Neg(inner) => format!("(-{})", emit_expr(&inner.node, ctx, ectx)),
        ResolvedExpr::BinOp(op, left, right) => {
            // BinOp: left and right use parent ectx (last_use on Resolved handles liveness)
            let l = emit_expr(&left.node, ctx, ectx);
            let r = emit_expr(&right.node, ctx, ectx);
            match op {
                BinOp::Add => {
                    if expr_is_numeric(&left.node, ectx) || expr_is_numeric(&right.node, ectx) {
                        // Both sides are numeric (Int/Float) — plain value add.
                        format!("({} + {})", l, r)
                    } else {
                        // Might be AverStr concatenation: Add<&AverStr>.
                        let l = maybe_clone(l, &left.node, ectx);
                        format!("({} + &{})", l, r)
                    }
                }
                _ => {
                    let op_str = match op {
                        BinOp::Add => unreachable!(),
                        BinOp::Sub => "-",
                        BinOp::Mul => "*",
                        BinOp::Div => "/",
                        BinOp::Eq => "==",
                        BinOp::Neq => "!=",
                        BinOp::Lt => "<",
                        BinOp::Gt => ">",
                        BinOp::Lte => "<=",
                        BinOp::Gte => ">=",
                    };
                    // For Eq/Neq with a string literal on either side, deref AverStr (Rc<str>)
                    // to &str for comparison since Rc<str> doesn't impl PartialEq<&str>.
                    if matches!(op, BinOp::Eq | BinOp::Neq) {
                        if let ResolvedExpr::Literal(Literal::Str(s)) = &right.node {
                            return format!("(&*{} {} {:?})", l, op_str, s);
                        }
                        if let ResolvedExpr::Literal(Literal::Str(s)) = &left.node {
                            return format!("({:?} {} &*{})", s, op_str, r);
                        }
                    }
                    format!("({} {} {})", l, op_str, r)
                }
            }
        }
        ResolvedExpr::Match { subject, arms, .. } => emit_match(&subject.node, arms, ctx, ectx),
        ResolvedExpr::Ctor(ctor, args) => emit_constructor(ctor, args, ctx, ectx),
        ResolvedExpr::ErrorProp(inner) => {
            let inner_str = emit_expr(&inner.node, ctx, ectx);
            format!("{}?", inner_str)
        }
        // Pipeline contract: `interp_lower` always runs before Rust codegen
        // — it rewrites `Expr::InterpolatedStr` to `__buf_*` + `__to_str`
        // intrinsic chains that the runtime backends share. Reaching this
        // arm means the pipeline was misconfigured (interp_lower disabled
        // for a path that emits Rust); bug in the caller.
        ResolvedExpr::InterpolatedStr(_) => unreachable!(
            "InterpolatedStr should have been lowered by ir::interp_lower; \
             Rust codegen runs only on lowered IR (see ir::pipeline contract)"
        ),
        ResolvedExpr::List(elements) => {
            if elements.is_empty() {
                "aver_rt::AverList::empty()".to_string()
            } else {
                let parts: Vec<String> = elements
                    .iter()
                    .map(|e| clone_arg(&e.node, ctx, ectx))
                    .collect();
                format!("aver_rt::AverList::from_vec(vec![{}])", parts.join(", "))
            }
        }
        ResolvedExpr::Tuple(items) => {
            let parts: Vec<String> = items
                .iter()
                .map(|e| clone_arg(&e.node, ctx, ectx))
                .collect();
            format!("({})", parts.join(", "))
        }
        ResolvedExpr::IndependentProduct(items, unwrap) => {
            let parts: Vec<String> = items
                .iter()
                .map(|e| clone_arg(&e.node, ctx, ectx))
                .collect();

            let n = parts.len();
            let has_replay = ctx.emit_replay_runtime;

            let mut code = String::new();
            if has_replay {
                // Runtime branch: if recording/replaying, execute sequentially
                // with replay groups (thread_local state stays on one thread).
                code.push_str("if crate::aver_replay::is_effect_tracking_active() { ");
                code.push_str("crate::aver_replay::enter_effect_group(); ");
                for (i, part) in parts.iter().enumerate() {
                    code.push_str(&format!(
                        "crate::aver_replay::set_effect_branch({i}); let _r{i} = {part}; "
                    ));
                }
                code.push_str("crate::aver_replay::exit_effect_group(); ");
                if *unwrap {
                    code.push_str(&emit_result_tuple_unwrap("_r", "__v", n));
                    code.push('?');
                } else {
                    code.push_str(&emit_tuple_from_vars("_r", n));
                }
                code.push_str(" } else { ");
            }

            if *unwrap {
                code.push_str("{ ");
                if has_replay {
                    code.push_str(
                        "let __parallel_scope = crate::aver_replay::capture_parallel_scope_context(); ",
                    );
                }
                code.push_str(
                    "let __cancel_flag = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false)); ",
                );
                code.push_str("std::thread::scope(|_s| { ");
                for (i, part) in parts.iter().enumerate() {
                    if has_replay {
                        code.push_str(&format!(
                            "let __parallel_scope{i} = __parallel_scope.clone(); "
                        ));
                    }
                    code.push_str(&format!("let __cancel_flag{i} = __cancel_flag.clone(); "));
                    code.push_str(&format!("let _h{i} = _s.spawn(move || "));
                    if has_replay {
                        code.push_str(&format!(
                            "crate::aver_replay::with_parallel_scope_context(__parallel_scope{i}.clone(), move || "
                        ));
                    }
                    code.push_str("{ crate::run_cancelable_branch(__cancel_flag");
                    code.push_str(&i.to_string());
                    code.push_str(".clone(), move || { let __result = ");
                    code.push_str(part);
                    code.push_str("; if let Err(_) = &__result { __cancel_flag");
                    code.push_str(&i.to_string());
                    code.push_str(
                        ".store(true, std::sync::atomic::Ordering::Relaxed); } __result }) }",
                    );
                    if has_replay {
                        code.push(')');
                    }
                    code.push_str("); ");
                }
                for i in 0..n {
                    code.push_str(&format!("let _b{i} = _h{i}.join().unwrap(); "));
                }
                code.push_str(&emit_parallel_result_tuple_unwrap("_b", "_r", "__v", n));
                code.push_str(" })? }");
            } else {
                if has_replay {
                    code.push_str(
                        "let __parallel_scope = crate::aver_replay::capture_parallel_scope_context(); ",
                    );
                }
                code.push_str("std::thread::scope(|_s| { ");
                for (i, part) in parts.iter().enumerate() {
                    if has_replay {
                        code.push_str(&format!(
                            "let __parallel_scope{i} = __parallel_scope.clone(); "
                        ));
                        code.push_str(&format!(
                            "let _h{i} = _s.spawn(move || crate::aver_replay::with_parallel_scope_context(__parallel_scope{i}.clone(), move || {part})); "
                        ));
                    } else {
                        code.push_str(&format!("let _h{i} = _s.spawn(move || {part}); "));
                    }
                }
                for i in 0..n {
                    code.push_str(&format!("let _r{i} = _h{i}.join().unwrap(); "));
                }
                code.push_str(&emit_tuple_from_vars("_r", n));
                code.push_str(" }) ");
            }

            if has_replay {
                code.push('}');
            }
            code
        }
        ResolvedExpr::MapLiteral(entries) => {
            if entries.is_empty() {
                "HashMap::new()".to_string()
            } else {
                let mut parts = Vec::new();
                for (k, v) in entries.iter() {
                    parts.push(format!(
                        "({}, {})",
                        clone_arg(&k.node, ctx, ectx),
                        clone_arg(&v.node, ctx, ectx)
                    ));
                }
                format!(
                    "vec![{}].into_iter().collect::<HashMap<_, _>>()",
                    parts.join(", ")
                )
            }
        }
        ResolvedExpr::RecordCreate {
            type_name, fields, ..
        } => {
            let rust_type = if type_name == "Tcp.Connection" {
                "Tcp_Connection"
            } else {
                type_name
            };
            let parts: Vec<String> = fields
                .iter()
                .map(|(name, expr)| {
                    format!(
                        "{}: {}",
                        aver_name_to_rust(name),
                        clone_arg(&expr.node, ctx, ectx)
                    )
                })
                .collect();
            format!("{} {{ {} }}", rust_type, parts.join(", "))
        }
        ResolvedExpr::RecordUpdate {
            type_name,
            base,
            updates,
            ..
        } => {
            let rust_type = if type_name == "Tcp.Connection" {
                "Tcp_Connection"
            } else {
                type_name
            };
            let base_str = clone_arg(&base.node, ctx, ectx);
            let parts: Vec<String> = updates
                .iter()
                .map(|(name, expr)| {
                    format!(
                        "{}: {}",
                        aver_name_to_rust(name),
                        clone_arg(&expr.node, ctx, ectx)
                    )
                })
                .collect();
            format!("{} {{ {}, ..{} }}", rust_type, parts.join(", "), base_str)
        }
        ResolvedExpr::TailCall { target, args } => {
            // TailCall outside of a TCO loop → emit as regular function call.
            // The resolver already mapped the source target name to a `FnId`;
            // recover the canonical "Module.fn" form for the emitter.
            let target_name = ctx.symbol_table.fn_entry(*target).key.canonical();
            emit_named_function_call(&target_name, args, ctx, ectx)
        }
    }
}

pub(super) fn emit_body_plan_for_rust(
    plan: &ResolvedBodyPlan<'_>,
    ctx: &CodegenContext,
    ectx: &EmitCtx,
) -> String {
    emit_body_plan_for_rust_with_options(plan, ctx, ectx, true)
}

fn emit_body_plan_for_rust_with_options(
    plan: &ResolvedBodyPlan<'_>,
    ctx: &CodegenContext,
    ectx: &EmitCtx,
    allow_callsite_inlining: bool,
) -> String {
    match plan {
        ResolvedBodyPlan::SingleExpr(body_expr) => {
            emit_body_expr_plan_with_options(body_expr, ctx, ectx, allow_callsite_inlining)
        }
        ResolvedBodyPlan::Block {
            stmts: _,
            bindings,
            tail,
        } => {
            let mut lines = Vec::with_capacity(bindings.len() + 1);
            for binding in bindings.iter() {
                lines.push(format!(
                    "let {} = {};",
                    aver_name_to_rust(binding.name),
                    emit_body_expr_plan_with_options(
                        &binding.expr,
                        ctx,
                        ectx,
                        allow_callsite_inlining,
                    )
                ));
            }
            lines.push(emit_body_expr_plan_with_options(
                tail,
                ctx,
                ectx,
                allow_callsite_inlining,
            ));
            lines.join("\n    ")
        }
    }
}

fn emit_body_expr_plan_with_options(
    plan: &ResolvedBodyExprPlan<'_>,
    ctx: &CodegenContext,
    ectx: &EmitCtx,
    allow_callsite_inlining: bool,
) -> String {
    match plan {
        ResolvedBodyExprPlan::Expr(expr) => {
            let code = emit_expr_with_options(expr, ctx, ectx, allow_callsite_inlining);
            // Field access on a borrowed param in return position needs .clone()
            // to produce an owned value (emit_expr produces `obj.field` without clone).
            if let ResolvedExpr::Attr(obj, _) = expr
                && let ResolvedExpr::Ident(name) | ResolvedExpr::Resolved { name, .. } = &obj.node
                && ectx.is_borrowed_param(name)
            {
                return format!("{}.clone()", code);
            }
            code
        }
        ResolvedBodyExprPlan::Leaf(leaf) => {
            let code = emit_leaf_op_with_options(leaf, ctx, ectx, allow_callsite_inlining);
            // Field access on a borrowed param in return position needs .clone()
            // to produce an owned value.
            if let ResolvedLeafOp::FieldAccess { object, .. } = leaf
                && let ResolvedExpr::Ident(name) | ResolvedExpr::Resolved { name, .. } =
                    &object.node
                && ectx.is_borrowed_param(name)
            {
                return format!("{}.clone()", code);
            }
            code
        }
        ResolvedBodyExprPlan::Call { callee, args } => {
            emit_call_dispatch_with_options(callee, args, ctx, ectx, allow_callsite_inlining)
        }
        ResolvedBodyExprPlan::ForwardCall(plan) => {
            emit_forward_call_plan_with_options(plan, ctx, ectx, allow_callsite_inlining)
        }
    }
}

fn emit_literal(lit: &Literal) -> String {
    match lit {
        Literal::Int(i) => format!("{}i64", i),
        Literal::Float(f) => {
            let s = f.to_string();
            if s.contains('.') || s.contains('e') || s.contains('E') {
                format!("{}f64", s)
            } else {
                format!("{}.0f64", s)
            }
        }
        Literal::Str(s) => format!("AverStr::from({:?})", s),
        Literal::Bool(b) => if *b { "true" } else { "false" }.to_string(),
        Literal::Unit => "()".to_string(),
    }
}

fn emit_codegen_error_expr(message: String) -> String {
    let message_lit = format!("{:?}", message);
    format!(
        "{{ compile_error!({}); unreachable!(\"unreachable after compile_error\") }}",
        message_lit
    )
}

fn emit_fn_call_with_options(
    callee: &ResolvedCallee,
    args: &[Spanned<ResolvedExpr>],
    ctx: &CodegenContext,
    ectx: &EmitCtx,
    allow_callsite_inlining: bool,
) -> String {
    let plan = call_plan_from_resolved_callee(callee, &ctx.symbol_table);
    match plan {
        CallPlan::Dynamic => {
            // Only LocalSlot reaches here; the resolver maps source lambdas
            // and dynamic callees to `ResolvedCallee::LocalSlot { name, .. }`
            // / `Unresolved`. Recover the name for emission.
            let func = match callee {
                ResolvedCallee::LocalSlot { name, .. } => aver_name_to_rust(name),
                ResolvedCallee::Unresolved { callee } => {
                    emit_expr_with_options(&callee.node, ctx, ectx, allow_callsite_inlining)
                }
                _ => unreachable!("CallPlan::Dynamic only from LocalSlot/Unresolved"),
            };
            let arg_strs: Vec<String> =
                args.iter().map(|a| clone_arg(&a.node, ctx, ectx)).collect();
            format!("{}({})", func, arg_strs.join(", "))
        }
        _ => emit_call_plan_with_args_with_options(&plan, args, ctx, ectx, allow_callsite_inlining),
    }
}

fn emit_call_dispatch_with_options(
    callee: &ResolvedCallee,
    args: &[Spanned<ResolvedExpr>],
    ctx: &CodegenContext,
    ectx: &EmitCtx,
    allow_callsite_inlining: bool,
) -> String {
    emit_fn_call_with_options(callee, args, ctx, ectx, allow_callsite_inlining)
}

fn emit_call_plan_with_args_with_options(
    plan: &CallPlan,
    args: &[Spanned<ResolvedExpr>],
    ctx: &CodegenContext,
    ectx: &EmitCtx,
    _allow_callsite_inlining: bool,
) -> String {
    match plan {
        CallPlan::Builtin(name) => builtins::emit_builtin_call(name, args, ctx, ectx)
            .unwrap_or_else(|| {
                emit_codegen_error_expr(format!(
                    "Rust codegen: unhandled builtin call lowering for {}",
                    name
                ))
            }),
        CallPlan::Wrapper(_) | CallPlan::NoneValue | CallPlan::TypeConstructor { .. } => {
            // Wrapper / None / TypeConstructor variants exist on `CallPlan`
            // for the pre-Phase-E `Expr::FnCall` path. The resolver lifts
            // every constructor call into `ResolvedExpr::Ctor`, so these
            // never reach the call emitter. If they do, it's a bug in the
            // resolver.
            emit_codegen_error_expr(format!(
                "Rust codegen: ctor-shaped CallPlan in call position: {:?}",
                plan
            ))
        }
        CallPlan::Function(name) => emit_named_function_call(name, args, ctx, ectx),
        CallPlan::Dynamic => emit_codegen_error_expr(
            "Rust codegen: dynamic call passed to direct call emitter".to_string(),
        ),
    }
}

fn emit_forward_call_plan_with_options(
    plan: &crate::ir::hir::ResolvedForwardCallPlan<'_>,
    ctx: &CodegenContext,
    ectx: &EmitCtx,
    allow_callsite_inlining: bool,
) -> String {
    let target = call_plan_from_resolved_callee(plan.callee, &ctx.symbol_table);
    emit_call_plan_with_args_with_options(&target, plan.args, ctx, ectx, allow_callsite_inlining)
}

fn emit_leaf_op_with_options(
    leaf: &ResolvedLeafOp<'_>,
    ctx: &CodegenContext,
    ectx: &EmitCtx,
    allow_callsite_inlining: bool,
) -> String {
    match leaf {
        ResolvedLeafOp::FieldAccess { object, field_name } => {
            let object = emit_expr_with_options(&object.node, ctx, ectx, allow_callsite_inlining);
            format!("{}.{}", object, aver_name_to_rust(field_name))
        }
        ResolvedLeafOp::MapGet { map, key } => emit_leaf_builtin_call_with_options(
            "Map.get",
            &[map, key],
            ctx,
            ectx,
            allow_callsite_inlining,
        ),
        ResolvedLeafOp::MapSet { map, key, value } => emit_leaf_builtin_call_with_options(
            "Map.set",
            &[map, key, value],
            ctx,
            ectx,
            allow_callsite_inlining,
        ),
        ResolvedLeafOp::VectorNew { size, fill } => emit_leaf_builtin_call_with_options(
            "Vector.new",
            &[size, fill],
            ctx,
            ectx,
            allow_callsite_inlining,
        ),
        ResolvedLeafOp::VectorSetOrDefaultSameVector {
            vector,
            index,
            value,
        } => {
            let vector = clone_arg_with_options(&vector.node, ctx, ectx, allow_callsite_inlining);
            let index = emit_expr_with_options(&index.node, ctx, ectx, allow_callsite_inlining);
            let value = clone_arg_with_options(&value.node, ctx, ectx, allow_callsite_inlining);
            format!(
                "{{ let __vec = {}; let __idx = {} as usize; if __idx < __vec.len() {{ __vec.set_unchecked(__idx, {}) }} else {{ __vec }} }}",
                vector, index, value
            )
        }
        ResolvedLeafOp::VectorGetOrDefaultLiteral {
            vector,
            index,
            default_literal,
        } => {
            let vector = emit_expr_with_options(&vector.node, ctx, ectx, allow_callsite_inlining);
            let index = emit_expr_with_options(&index.node, ctx, ectx, allow_callsite_inlining);
            let default = emit_literal(default_literal);
            format!(
                "{}.get({} as usize).cloned().unwrap_or({})",
                vector, index, default
            )
        }
        ResolvedLeafOp::IntModOrDefaultLiteral {
            a,
            b,
            default_literal,
        } => {
            // When divisor is a known non-zero literal, skip the zero check entirely.
            if let ResolvedExpr::Literal(Literal::Int(n)) = &b.node
                && *n != 0
            {
                let a = emit_expr_with_options(&a.node, ctx, ectx, allow_callsite_inlining);
                let b_str = emit_literal(&Literal::Int(*n));
                format!("({}).rem_euclid({})", a, b_str)
            } else {
                let a = emit_expr_with_options(&a.node, ctx, ectx, allow_callsite_inlining);
                let b = emit_expr_with_options(&b.node, ctx, ectx, allow_callsite_inlining);
                let default = emit_literal(default_literal);
                format!(
                    "{{ let __b = {}; if __b == 0i64 {{ {} }} else {{ ({}).rem_euclid(__b) }} }}",
                    b, default, a
                )
            }
        }
        ResolvedLeafOp::ListIndexGet { list, index } => {
            let list = emit_expr_with_options(&list.node, ctx, ectx, allow_callsite_inlining);
            let index = emit_expr_with_options(&index.node, ctx, ectx, allow_callsite_inlining);
            format!("{}.to_vec().get({} as usize).cloned()", list, index)
        }
        ResolvedLeafOp::NoneValue => "None".to_string(),
        ResolvedLeafOp::VariantConstructor {
            qualified_type_name,
            variant_name,
        } => {
            if let Some((prefix, _)) = resolve_module_call(qualified_type_name, ctx) {
                let module_path = module_prefix_to_rust_path(prefix);
                let bare_type = qualified_type_name
                    .rsplit_once('.')
                    .map(|(_, t)| t)
                    .unwrap_or(qualified_type_name);
                format!("{}::{}::{}", module_path, bare_type, variant_name)
            } else {
                format!("{}::{}", qualified_type_name, variant_name)
            }
        }
        ResolvedLeafOp::StaticRef(name) => {
            // Refinement: when the dotted reference resolves to a known
            // user-defined variant (`Shape.Point`,
            // `Domain.Shape.Circle`), emit the Rust enum-variant form
            // (`Shape::Point`) rather than the namespace-deref shape
            // that's appropriate for static fn references
            // (`Fibonacci::fib`). Mirrors the pre-Phase-E
            // `classify_call_plan` → `VariantConstructor` dispatch
            // that produced the same source.
            if name == "Option.None" || name == "None" {
                return "None".to_string();
            }
            if let Some((type_name, variant_name)) = name.rsplit_once('.') {
                let is_user = |n: &str| crate::codegen::common::is_user_type(n, ctx);
                if is_user(type_name) {
                    return if let Some((prefix, _)) = resolve_module_call(name, ctx) {
                        let module_path = module_prefix_to_rust_path(prefix);
                        let bare_type = type_name
                            .rsplit_once('.')
                            .map(|(_, t)| t)
                            .unwrap_or(type_name);
                        format!("{}::{}::{}", module_path, bare_type, variant_name)
                    } else {
                        format!("{}::{}", type_name, variant_name)
                    };
                }
                if let Some((_, bare_type)) = type_name.rsplit_once('.')
                    && is_user(bare_type)
                {
                    return if let Some((prefix, _)) = resolve_module_call(name, ctx) {
                        let module_path = module_prefix_to_rust_path(prefix);
                        format!("{}::{}::{}", module_path, bare_type, variant_name)
                    } else {
                        format!("{}::{}", bare_type, variant_name)
                    };
                }
            }
            if let Some((prefix, bare)) = resolve_module_call(name, ctx) {
                let module_path = module_prefix_to_rust_path(prefix);
                format!("{}::{}", module_path, aver_name_to_rust(bare))
            } else {
                aver_name_to_rust(name)
            }
        }
    }
}

fn emit_leaf_builtin_call_with_options(
    name: &str,
    args: &[&Spanned<ResolvedExpr>],
    ctx: &CodegenContext,
    ectx: &EmitCtx,
    _allow_callsite_inlining: bool,
) -> String {
    let owned_args = args
        .iter()
        .map(|spanned| (*spanned).clone())
        .collect::<Vec<_>>();
    builtins::emit_builtin_call(name, &owned_args, ctx, ectx).unwrap_or_else(|| {
        emit_codegen_error_expr(format!(
            "Rust codegen: missing leaf builtin lowering for {}",
            name
        ))
    })
}

/// Compute borrow mask from a FnDef, checking for TCO.
/// Must mirror actual emitted signature:
/// - Mutual-TCO SCC members → wrapper with borrow-by-default (`&T`)
/// - Self-TCO only (not in SCC) → loop with `mut T`, all-false mask
/// - Non-TCO → borrow-by-default
fn borrow_mask_from_fn_def(
    fd: &crate::ast::FnDef,
    arg_count: usize,
    ctx: &CodegenContext,
) -> Vec<bool> {
    // Mutual-TCO members are emitted as wrappers with borrow-by-default,
    // even if they also have self-TailCalls. Don't skip borrow for them.
    // Memo functions always use borrow-by-default (memo wrapper takes &T),
    // even if the body has self-tail-calls.
    let is_memo = ctx.memo_fns.contains(&fd.name);
    let is_mutual_tco = crate::codegen::common::fn_id_for_decl(ctx, fd)
        .is_some_and(|id| ctx.mutual_tco_members.contains(&id));
    if !is_memo && !is_mutual_tco && super::toplevel::body_has_self_tailcall(&fd.body, &fd.name) {
        return vec![false; arg_count];
    }
    fd.params
        .iter()
        .take(arg_count)
        .map(|(_, type_ann)| {
            let ty = crate::types::parse_type_str(type_ann);
            should_borrow_param(&ty)
        })
        .collect()
}

/// Look up whether the callee's i-th parameter is borrowed (`&T`).
/// Returns a Vec of booleans, one per parameter, indicating borrow status.
/// Uses the resolved-program view for typed param types; falls back to
/// `FnDef` AST annotations when the callee isn't in the view (only TCO
/// status reads from the AST `FnDef`).
/// TCO functions (self or mutual) never use borrow-by-default.
fn callee_borrow_mask(name: &str, arg_count: usize, ctx: &CodegenContext) -> Vec<bool> {
    // First, try to find the FnDef to check for TCO (which overrides everything)
    let fd = find_fn_def_by_name(name, ctx);
    if let Some(fd) = fd {
        return borrow_mask_from_fn_def(fd, arg_count, ctx);
    }

    // No FnDef found — read param types from the resolved-program
    // view. The qualified lookup hits cross-module callsites that
    // arrive as bare dotted names; the bare-name fallback covers
    // entry-scope synthesised wrappers.
    let lookup_name = if let Some((prefix, bare)) = resolve_module_call(name, ctx) {
        crate::visibility::qualified_name(prefix, bare)
    } else {
        name.to_string()
    };
    let resolved = crate::codegen::common::fn_id_for_dotted_name(ctx, &lookup_name)
        .or_else(|| crate::codegen::common::fn_id_for_dotted_name(ctx, name))
        .and_then(|id| ctx.resolved_program.fn_by_id(id));
    if let Some(rfd) = resolved {
        // Self-TCO functions always resolve via `find_fn_def_by_name`
        // above, so this path is safe for borrow-by-default on all
        // non-scalar types including Named.
        return rfd
            .params
            .iter()
            .take(arg_count)
            .map(|(_, ty)| should_borrow_param(ty))
            .collect();
    }

    // Unknown function -- don't borrow (conservative)
    vec![false; arg_count]
}

/// Find a FnDef by name, checking top-level, modules (qualified), and all modules (unqualified).
///
/// **syntax-discovery-only** (epic #170 invariant): used by
/// `callee_borrow_mask` to read param-type annotations from the AST
/// `FnDef` for borrow-by-default inference. Identity-sensitive call
/// dispatch already happens upstream via `ResolvedCallee::Fn(FnId)`
/// — this lookup only recovers the AST view for downstream
/// annotation reads. A future PR can route through
/// `symbol_table.fn_id_of` + `resolved_program.fn_by_id` once the
/// borrow-mask inference consumes resolved param types directly.
fn find_fn_def_by_name<'a>(name: &str, ctx: &'a CodegenContext) -> Option<&'a crate::ast::FnDef> {
    // Check top-level fn_defs
    if let Some(fd) = ctx.fn_defs.iter().find(|fd| fd.name == name) {
        return Some(fd);
    }

    // Check extra fn_defs (current module being emitted)
    if let Some(fd) = ctx.extra_fn_defs.iter().find(|fd| fd.name == name) {
        return Some(fd);
    }

    // Check module fn_defs for qualified calls
    if let Some((prefix, bare)) = resolve_module_call(name, ctx) {
        for module in &ctx.modules {
            if module.prefix == prefix
                && let Some(fd) = module.fn_defs.iter().find(|fd| fd.name == bare)
            {
                return Some(fd);
            }
        }
    }

    None
}

fn emit_named_function_call(
    name: &str,
    args: &[Spanned<ResolvedExpr>],
    ctx: &CodegenContext,
    ectx: &EmitCtx,
) -> String {
    let borrow_mask = callee_borrow_mask(name, args.len(), ctx);
    let arg_strs: Vec<String> = args
        .iter()
        .enumerate()
        .map(|(i, a)| {
            if borrow_mask.get(i).copied().unwrap_or(false) {
                borrow_arg(&a.node, ctx, ectx)
            } else {
                clone_arg(&a.node, ctx, ectx)
            }
        })
        .collect();

    if let Some((prefix, bare)) = resolve_module_call(name, ctx) {
        let module_path = module_prefix_to_rust_path(prefix);
        format!(
            "{}::{}({})",
            module_path,
            aver_name_to_rust(bare),
            arg_strs.join(", ")
        )
    } else {
        format!("{}({})", aver_name_to_rust(name), arg_strs.join(", "))
    }
}

fn emit_type_constructor_call(
    qualified_type_name: &str,
    variant_name: &str,
    args: &[Spanned<ResolvedExpr>],
    ctx: &CodegenContext,
    ectx: &EmitCtx,
) -> String {
    let ctor_name = format!("{}.{}", qualified_type_name, variant_name);
    let boxed_positions = constructor_boxed_positions(&ctor_name, ctx);
    let arg_strs: Vec<String> = args
        .iter()
        .enumerate()
        .map(|(idx, a)| {
            let arg = clone_arg(&a.node, ctx, ectx);
            if boxed_positions.contains(&idx) {
                format!("std::sync::Arc::new({})", arg)
            } else {
                arg
            }
        })
        .collect();

    if let Some((prefix, bare_type_name)) = resolve_module_call(qualified_type_name, ctx) {
        let module_path = module_prefix_to_rust_path(prefix);
        format!(
            "{}::{}::{}({})",
            module_path,
            bare_type_name,
            variant_name,
            arg_strs.join(", ")
        )
    } else {
        format!(
            "{}::{}({})",
            qualified_type_name,
            variant_name,
            arg_strs.join(", ")
        )
    }
}

/// Clone a value if it's a variable reference (to avoid move issues in generated Rust).
/// Literals and complex expressions don't need cloning.
///
/// For borrowed params (`&T` from borrow-by-default), the default behavior is to
/// produce an owned clone. Call sites for user functions override this via `borrow_arg`.
pub(super) fn maybe_clone(code: String, expr: &ResolvedExpr, ectx: &EmitCtx) -> String {
    match expr {
        ResolvedExpr::Ident(name) | ResolvedExpr::Resolved { name, .. } => {
            if expr_skip_clone(expr, ectx) {
                code
            } else if ectx.is_rc_wrapped(name) {
                // Pass-through param (Rc<T> in self-TCO, &T in mutual-TCO trampoline).
                // For Rc<T>: `(*param).clone()` derefs Rc then clones inner T.
                // For &T: `(*param).clone()` derefs borrow then clones inner T.
                // Both produce owned T at the call site.
                format!("(*{}).clone()", code)
            } else if ectx.is_borrowed_param(name) {
                // Borrowed param: clone to produce owned T (e.g. for return position,
                // constructors, wrappers). User function calls use `borrow_arg` instead.
                format!("{}.clone()", code)
            } else {
                format!("{}.clone()", code)
            }
        }
        // Field access on records: emit_expr produces `obj.field` without clone.
        // Clone here when ownership is needed (constructors, return, etc.).
        // When passed to a function expecting `&T`, `borrow_arg` handles it.
        ResolvedExpr::Attr(obj, _field) => {
            // Builtin namespace access (e.g. Int.abs) → no clone needed
            if matches!(&obj.node, ResolvedExpr::Ident(name) if crate::ir::is_builtin_namespace(name))
            {
                code
            } else {
                format!("{}.clone()", code)
            }
        }
        _ => code,
    }
}

/// Is this expression known to produce a numeric (Int/Float) value?
/// Used to decide whether `+` needs `&` on the RHS (only strings do).
fn expr_is_numeric(expr: &ResolvedExpr, ectx: &EmitCtx) -> bool {
    match expr {
        ResolvedExpr::Literal(Literal::Int(_) | Literal::Float(_)) => true,
        ResolvedExpr::Ident(name) | ResolvedExpr::Resolved { name, .. } => {
            matches!(
                ectx.local_types.get(name.as_str()),
                Some(Type::Int | Type::Float)
            )
        }
        // Sub/Mul/Div always produce numeric results.
        ResolvedExpr::BinOp(op, _, _) => !matches!(op, BinOp::Add),
        ResolvedExpr::Call(ResolvedCallee::Builtin(name), _) => matches!(
            name.as_str(),
            "Int.abs"
                | "Int.min"
                | "Int.max"
                | "Float.abs"
                | "Float.floor"
                | "Float.ceil"
                | "Float.round"
                | "Float.min"
                | "Float.max"
                | "Float.sqrt"
                | "Float.pow"
                | "Float.sin"
                | "Float.cos"
                | "Float.atan2"
                | "Float.fromInt"
                | "List.len"
                | "Vector.len"
                | "Map.len"
                | "String.len"
                | "String.byteLength"
                | "Char.toCode"
        ),
        _ => false,
    }
}

/// Is a record field access known to return a Copy type?
/// Looks up the record definition in the context to find the field's type.
fn attr_result_is_copy(
    obj: &ResolvedExpr,
    field: &str,
    ctx: &CodegenContext,
    ectx: &EmitCtx,
) -> bool {
    let obj_type = match obj {
        ResolvedExpr::Ident(name) | ResolvedExpr::Resolved { name, .. } => {
            ectx.local_types.get(name)
        }
        _ => None,
    };
    let Some(named_ty) = obj_type.filter(|t| matches!(t, Type::Named { .. })) else {
        return false;
    };
    let Some(record_key) = crate::codegen::common::backend_named_type_key(ctx, named_ty) else {
        return false;
    };
    // Find record definition and look up field type. Iterate
    // through `(module_prefix, td)` pairs so canonical-key
    // matching (`"A.Shape"`) routes to the right module's
    // TypeDef list instead of first-bare-match-wins.
    let candidates = ctx
        .type_defs
        .iter()
        .map(|td| (None, td))
        .chain(ctx.modules.iter().flat_map(|m| {
            m.type_defs
                .iter()
                .map(move |td| (Some(m.prefix.as_str()), td))
        }));
    for (scope, td) in candidates {
        if let TypeDef::Product { name, fields, .. } = td {
            let canonical = match scope {
                Some(prefix) => format!("{}.{}", prefix, name),
                None => name.clone(),
            };
            if canonical == record_key
                && let Some((_, type_ann)) = fields.iter().find(|(n, _)| n == field)
            {
                let ty = types::parse_type_str(type_ann);
                return super::emit_ctx::is_copy_type(&ty);
            }
        }
    }
    false
}

/// Emit an expression as a borrow for passing to a user function that takes `&T`.
/// For borrowed params: pass directly (already `&T`).
/// For owned locals: pass `&x`.
/// For Copy types: pass by value (no borrow needed).
/// For AverStr: pass by value (cheap clone).
pub(super) fn borrow_arg(expr: &ResolvedExpr, ctx: &CodegenContext, ectx: &EmitCtx) -> String {
    let code = emit_expr(expr, ctx, ectx);
    match expr {
        ResolvedExpr::Ident(name) => {
            if ectx.is_copy(name) {
                // Copy type: pass by value
                code
            } else if ectx
                .local_types
                .get(name)
                .is_some_and(|ty| matches!(ty, Type::Str))
            {
                // AverStr (Rc<str>): pass by value (cheap clone if needed)
                // Ident (globals) are always moveable
                if ectx.is_rc_wrapped(name) {
                    format!("(*{}).clone()", code)
                } else {
                    code
                }
            } else if ectx.is_borrowed_param(name) {
                // Already `&T` — pass directly
                code
            } else if ectx.is_rc_wrapped(name) {
                // Pass-through TCO param (Rc<T> or &T): deref to get &T
                format!("&*{}", code)
            } else {
                // Owned local: borrow it
                format!("&{}", code)
            }
        }
        ResolvedExpr::Resolved { name, .. } => {
            if ectx.is_copy(name) {
                code
            } else if ectx
                .local_types
                .get(name)
                .is_some_and(|ty| matches!(ty, Type::Str))
            {
                // AverStr: check last_use for move eligibility
                if expr_can_move(expr) {
                    code
                } else if ectx.is_rc_wrapped(name) {
                    format!("(*{}).clone()", code)
                } else {
                    format!("{}.clone()", code)
                }
            } else if ectx.is_borrowed_param(name) {
                code
            } else if ectx.is_rc_wrapped(name) {
                format!("&*{}", code)
            } else if expr_can_move(expr) {
                // Last use: can move, borrow the owned value
                format!("&{}", code)
            } else {
                // Not last use: clone then borrow
                format!("&{}", code)
            }
        }
        _ => {
            // Complex expression: emit and borrow the result.
            // Check if the expression type needs borrowing by looking at what
            // the callee expects. For complex expressions, we produce a temporary
            // and borrow it.
            format!("&{}", code)
        }
    }
}

/// Emit an expression as a function argument, cloning variables to prevent move errors.
pub(super) fn clone_arg(expr: &ResolvedExpr, ctx: &CodegenContext, ectx: &EmitCtx) -> String {
    clone_arg_with_options(expr, ctx, ectx, true)
}

fn clone_arg_with_options(
    expr: &ResolvedExpr,
    ctx: &CodegenContext,
    ectx: &EmitCtx,
    allow_callsite_inlining: bool,
) -> String {
    let code = emit_expr_with_options(expr, ctx, ectx, allow_callsite_inlining);
    // Field access on record: check if the field type is Copy before cloning.
    if let ResolvedExpr::Attr(obj, field) = expr
        && attr_result_is_copy(&obj.node, field, ctx, ectx)
    {
        return code;
    }
    maybe_clone(code, expr, ectx)
}

fn emit_constructor(
    ctor: &ResolvedCtor,
    args: &[Spanned<ResolvedExpr>],
    ctx: &CodegenContext,
    ectx: &EmitCtx,
) -> String {
    match semantic_constructor_from_resolved_ctor(ctor, &ctx.symbol_table) {
        SemanticConstructor::Wrapper(kind) => {
            let wrapper_name = match kind {
                WrapperKind::ResultOk => "Result.Ok",
                WrapperKind::ResultErr => "Result.Err",
                WrapperKind::OptionSome => "Option.Some",
            };
            builtins::emit_builtin_call(wrapper_name, args, ctx, ectx).unwrap_or_else(|| {
                emit_codegen_error_expr(format!(
                    "Rust codegen: missing constructor wrapper lowering for {}",
                    wrapper_name
                ))
            })
        }
        SemanticConstructor::NoneValue => "None".to_string(),
        SemanticConstructor::TypeConstructor {
            qualified_type_name,
            variant_name,
        } => emit_type_constructor_call(&qualified_type_name, &variant_name, args, ctx, ectx),
        SemanticConstructor::Unknown(name) => {
            // Resolver fallback: typecheck rejected the program, and this
            // ctor reference couldn't be classified. Emit the bare name as
            // a unary function call as the legacy code did, so the
            // generated Rust still typechecks for the recovery path.
            let inner = args
                .first()
                .map(|a| clone_arg(&a.node, ctx, ectx))
                .unwrap_or_else(|| "()".to_string());
            format!("{}({})", name, inner)
        }
    }
}

fn is_irrefutable_pattern(pat: &ResolvedPattern) -> bool {
    match pat {
        ResolvedPattern::Wildcard | ResolvedPattern::Ident(_) => true,
        ResolvedPattern::Tuple(pats) => pats.iter().all(is_irrefutable_pattern),
        _ => false,
    }
}

fn emit_match(
    subject: &ResolvedExpr,
    arms: &[ResolvedMatchArm],
    ctx: &CodegenContext,
    ectx: &EmitCtx,
) -> String {
    // Single-arm irrefutable match → `let` destructuring instead of `match`.
    // e.g. `match x: (a, b) -> expr` → `{ let (a, b) = x; expr }`
    if arms.len() == 1 && is_irrefutable_pattern(&arms[0].pattern) {
        let arm = &arms[0];
        let subj = clone_arg(subject, ctx, ectx);
        let pat = emit_pattern(&arm.pattern, false, ctx);
        let body = maybe_clone(emit_expr(&arm.body.node, ctx, ectx), &arm.body.node, ectx);
        return match &arm.pattern {
            ResolvedPattern::Wildcard => body,
            ResolvedPattern::Ident(name) => {
                let name = aver_name_to_rust(name);
                format!("{{ let {} = {}; {} }}", name, subj, body)
            }
            _ => format!("{{ let {} = {}; {} }}", pat, subj, body),
        };
    }

    // For borrowed params, match on the reference directly instead of cloning,
    // but only when no arms have pattern bindings (destructuring produces &T refs
    // that would need clone rebindings across all match emission paths).
    let no_bindings = arms
        .iter()
        .all(|arm| resolved_pattern_bindings(&arm.pattern).is_empty());
    let match_on_ref = no_bindings
        && matches!(
            subject,
            ResolvedExpr::Ident(name) | ResolvedExpr::Resolved { name, .. } if ectx.is_borrowed_param(name)
        );
    let subj = if match_on_ref {
        emit_expr(subject, ctx, ectx)
    } else {
        clone_arg(subject, ctx, ectx)
    };
    let dispatch_plan = classify_dispatch_plan_for_rust(arms, ctx, ectx);

    // Bool match → if/else: match expr { true => A, false => B } → if expr { A } else { B }
    // Always applied (not just optimized) since it generates strictly better code.
    if let Some(MatchDispatchPlan::Bool(shape)) = dispatch_plan.as_ref()
        && let Some(code) = try_emit_bool_if_else(subject, &subj, arms, *shape, ctx, ectx, ectx)
    {
        return code;
    }

    // Determine if subject needs special treatment
    let needs_as_str = subject_might_be_string(subject, ctx);
    let _needs_as_slice = subject_might_be_list(subject, arms, ctx);

    if has_list_patterns(arms) {
        let list_shape = match dispatch_plan.as_ref() {
            Some(MatchDispatchPlan::List(shape)) => Some(*shape),
            _ => None,
        };
        return emit_list_match(subj, arms, list_shape, true, ctx, |arm| {
            maybe_clone(emit_expr(&arm.body.node, ctx, ectx), &arm.body.node, ectx)
        });
    }

    if let Some(MatchDispatchPlan::Table(shape)) = dispatch_plan.as_ref() {
        return emit_dispatch_table_match(subj, arms, shape, |arm| {
            maybe_clone(emit_expr(&arm.body.node, ctx, ectx), &arm.body.node, ectx)
        });
    }

    let match_expr = if needs_as_str && has_string_literal_patterns(arms) {
        format!("&*{}", subj)
    } else {
        subj
    };

    let mut arm_strs = Vec::new();
    for arm in arms {
        let pat = emit_pattern(&arm.pattern, needs_as_str, ctx);
        // Each arm body is independent — use parent's used_after
        // Clone the result if it's a bare ident that's still needed after the match
        let body = maybe_clone(emit_expr(&arm.body.node, ctx, ectx), &arm.body.node, ectx);
        let mut rebindings = emit_pattern_rebindings(&arm.pattern, ctx);
        // When matching on a reference (borrowed param), bindings are &T.
        // Clone them to produce owned values expected by arm bodies.
        if match_on_ref {
            let ref_rebinds = emit_ref_match_rebindings(&arm.pattern);
            if !ref_rebinds.is_empty() {
                rebindings = format!("{}{}", ref_rebinds, rebindings);
            }
        }
        arm_strs.push(format!(
            "        {} => {{\n            {}{}\n        }}",
            pat, rebindings, body
        ));
    }

    format!("match {} {{\n{}\n    }}", match_expr, arm_strs.join(",\n"))
}

/// If match has exactly two arms with `true` and `false` bool literal patterns,
/// emit `if subject { true_body } else { false_body }` instead of a match.
fn try_emit_bool_if_else(
    subject: &ResolvedExpr,
    subj: &str,
    arms: &[ResolvedMatchArm],
    shape: crate::ir::BoolMatchShape,
    ctx: &CodegenContext,
    subj_ectx: &EmitCtx,
    ectx: &EmitCtx,
) -> Option<String> {
    let (true_body, false_body, cond) = match classify_bool_subject_plan_resolved(subject) {
        ResolvedBoolSubjectPlan::Expr(_) => (
            &arms[shape.true_arm_index].body,
            &arms[shape.false_arm_index].body,
            subj.to_string(),
        ),
        ResolvedBoolSubjectPlan::Compare {
            lhs,
            rhs,
            op,
            invert,
        } => {
            let lhs_code = emit_expr(&lhs.node, ctx, subj_ectx);
            let rhs_code = emit_expr(&rhs.node, ctx, subj_ectx);
            let op_code = match op {
                BoolCompareOp::Eq => "==",
                BoolCompareOp::Lt => "<",
                BoolCompareOp::Gt => ">",
            };
            let cond = format!("({lhs_code} {op_code} {rhs_code})");
            if invert {
                (
                    &arms[shape.false_arm_index].body,
                    &arms[shape.true_arm_index].body,
                    cond,
                )
            } else {
                (
                    &arms[shape.true_arm_index].body,
                    &arms[shape.false_arm_index].body,
                    cond,
                )
            }
        }
    };
    let t = maybe_clone(emit_expr(&true_body.node, ctx, ectx), &true_body.node, ectx);
    let f = maybe_clone(
        emit_expr(&false_body.node, ctx, ectx),
        &false_body.node,
        ectx,
    );
    Some(format!("if {} {{ {} }} else {{ {} }}", cond, t, f))
}

fn subject_might_be_string(_subject: &ResolvedExpr, _ctx: &CodegenContext) -> bool {
    // Heuristic: if subject is an ident, we can't tell at codegen time
    // We'll rely on the patterns to decide
    true
}

fn subject_might_be_list(
    _subject: &ResolvedExpr,
    _arms: &[ResolvedMatchArm],
    _ctx: &CodegenContext,
) -> bool {
    true
}

pub(super) fn emit_dispatch_table_match<F>(
    subject: String,
    arms: &[ResolvedMatchArm],
    shape: &DispatchTableShape,
    body_for_arm: F,
) -> String
where
    F: Fn(&ResolvedMatchArm) -> String,
{
    // Fast path: if all entries are wrapper tags (Result/Option), emit a Rust `match`
    // with move bindings instead of if-chain + clone.  This is both shorter and faster
    // because it avoids cloning the inner value.
    if let Some(code) = try_emit_wrapper_match(&subject, arms, shape, &body_for_arm) {
        return code;
    }

    let subject_name = "__dispatch_subject";
    let fallback = match &shape.default_arm {
        Some(default_arm) => emit_default_dispatch_arm(
            subject_name,
            &arms[default_arm.arm_index],
            default_arm,
            &body_for_arm,
        ),
        None => "panic!(\"Aver Rust codegen: non-exhaustive dispatch match\")".to_string(),
    };

    let body = shape
        .entries
        .iter()
        .rev()
        .fold(fallback, |else_branch, entry| {
            let arm = &arms[entry.arm_index];
            let cond = emit_dispatch_condition(subject_name, &entry.pattern);
            let body = emit_dispatch_arm_body(subject_name, arm, entry, &body_for_arm);
            format!("if {} {{ {} }} else {{ {} }}", cond, body, else_branch)
        });

    format!("{{ let {} = {}; {} }}", subject_name, subject, body)
}

/// Emit `match subject { Ok(v) => ..., Err(e) => ... }` when ALL dispatch entries are
/// wrapper tags (Result.Ok/Err, Option.Some/None).  Bindings are by move (no clone).
fn try_emit_wrapper_match<F>(
    subject: &str,
    arms: &[ResolvedMatchArm],
    shape: &DispatchTableShape,
    body_for_arm: &F,
) -> Option<String>
where
    F: Fn(&ResolvedMatchArm) -> String,
{
    // All entries must be wrapper tags with payload bindings
    let all_wrappers = shape.entries.iter().all(|e| {
        matches!(
            e.pattern,
            SemanticDispatchPattern::WrapperTag(_) | SemanticDispatchPattern::NoneValue
        )
    });
    if !all_wrappers {
        return None;
    }

    let mut match_arms = Vec::new();
    for entry in &shape.entries {
        let arm = &arms[entry.arm_index];
        let body = body_for_arm(arm);
        match (&entry.pattern, &entry.binding) {
            (
                SemanticDispatchPattern::WrapperTag(kind),
                DispatchBindingPlan::WrapperPayload(name),
            ) => {
                let binding = aver_name_to_rust(name);
                let extractor = match kind {
                    WrapperKind::ResultOk => "Ok",
                    WrapperKind::ResultErr => "Err",
                    WrapperKind::OptionSome => "Some",
                };
                match_arms.push(format!("{extractor}({binding}) => {{ {body} }}"));
            }
            (SemanticDispatchPattern::WrapperTag(kind), DispatchBindingPlan::None) => {
                let pattern = match kind {
                    WrapperKind::ResultOk => "Ok(_)",
                    WrapperKind::ResultErr => "Err(_)",
                    WrapperKind::OptionSome => "Some(_)",
                };
                match_arms.push(format!("{pattern} => {{ {body} }}"));
            }
            (SemanticDispatchPattern::NoneValue, _) => {
                match_arms.push(format!("None => {{ {body} }}"));
            }
            _ => return None,
        }
    }

    // Default arm (wildcard)
    if let Some(default_arm) = &shape.default_arm {
        let arm = &arms[default_arm.arm_index];
        let body = body_for_arm(arm);
        if let Some(name) = &default_arm.binding_name {
            let binding = aver_name_to_rust(name);
            match_arms.push(format!("{binding} => {{ {body} }}"));
        } else {
            match_arms.push(format!("_ => {{ {body} }}"));
        }
    }

    Some(format!("match {} {{ {} }}", subject, match_arms.join(", ")))
}

fn emit_dispatch_condition(subject_name: &str, pattern: &SemanticDispatchPattern) -> String {
    match pattern {
        SemanticDispatchPattern::Literal(lit) => match lit {
            DispatchLiteral::Int(i) => format!("{subject_name} == {i}i64"),
            DispatchLiteral::Float(f) => format!("{subject_name} == {f}f64"),
            DispatchLiteral::Bool(b) => format!("{subject_name} == {b}"),
            DispatchLiteral::Str(s) => format!("&*{subject_name} == {:?}", s),
            DispatchLiteral::Unit => format!("{subject_name} == ()"),
        },
        SemanticDispatchPattern::EmptyList => format!("{subject_name}.is_empty()"),
        SemanticDispatchPattern::NoneValue => format!("{subject_name}.is_none()"),
        SemanticDispatchPattern::WrapperTag(kind) => match kind {
            WrapperKind::ResultOk => format!("{subject_name}.is_ok()"),
            WrapperKind::ResultErr => format!("{subject_name}.is_err()"),
            WrapperKind::OptionSome => format!("{subject_name}.is_some()"),
        },
    }
}

fn emit_dispatch_arm_body(
    subject_name: &str,
    arm: &ResolvedMatchArm,
    entry: &DispatchArmPlan,
    body_for_arm: &impl Fn(&ResolvedMatchArm) -> String,
) -> String {
    let body = body_for_arm(arm);
    match (&entry.pattern, &entry.binding) {
        (
            SemanticDispatchPattern::WrapperTag(kind),
            DispatchBindingPlan::WrapperPayload(binding_name),
        ) => {
            let binding = aver_name_to_rust(binding_name);
            let extractor = match kind {
                WrapperKind::ResultOk => "Ok",
                WrapperKind::ResultErr => "Err",
                WrapperKind::OptionSome => "Some",
            };
            format!(
                "{{ let {binding} = if let {extractor}({binding}) = &{subject_name} {{ {binding}.clone() }} else {{ unreachable!(\"Aver Rust codegen: dispatch tag mismatch\") }}; {body} }}"
            )
        }
        _ => body,
    }
}

fn emit_default_dispatch_arm(
    subject_name: &str,
    arm: &ResolvedMatchArm,
    default_arm: &DispatchDefaultPlan,
    body_for_arm: &impl Fn(&ResolvedMatchArm) -> String,
) -> String {
    let body = body_for_arm(arm);
    match &default_arm.binding_name {
        None => body,
        Some(name) => {
            let name = aver_name_to_rust(name);
            format!("{{ let {} = {}.clone(); {} }}", name, subject_name, body)
        }
    }
}

pub(super) fn emit_list_match<F>(
    subject: String,
    arms: &[ResolvedMatchArm],
    list_shape: Option<ListMatchShape>,
    allow_fast_macro: bool,
    ctx: &CodegenContext,
    body_for_arm: F,
) -> String
where
    F: Fn(&ResolvedMatchArm) -> String,
{
    // Fast path: exactly [] and [h, ..t] → use aver_list_match! macro
    if allow_fast_macro
        && let Some(code) =
            try_emit_list_match_macro(&subject, arms, list_shape, ctx, &body_for_arm)
    {
        return code;
    }
    let subject_name = "__list_subject";
    let arms_code = emit_list_match_arms(subject_name, arms, ctx, &body_for_arm);
    format!("{{ let {} = {}; {} }}", subject_name, subject, arms_code)
}

/// Emit the aver_list_match! macro for the common []/[h,..t] two-arm pattern.
fn try_emit_list_match_macro<F>(
    subject: &str,
    arms: &[ResolvedMatchArm],
    list_shape: Option<ListMatchShape>,
    ctx: &CodegenContext,
    body_for_arm: &F,
) -> Option<String>
where
    F: Fn(&ResolvedMatchArm) -> String,
{
    let shape = match list_shape {
        Some(shape) => shape,
        None => classify_list_match_shape_resolved(arms)?,
    };
    let empty_arm = &arms[shape.empty_arm_index];
    let cons_arm = &arms[shape.cons_arm_index];
    let ResolvedPattern::Cons(head, tail) = &cons_arm.pattern else {
        return None;
    };
    // Both names must be real idents (not _) for the macro binding
    if head == "_" || tail == "_" {
        return None;
    }
    let head_name = aver_name_to_rust(head);
    let tail_name = aver_name_to_rust(tail);
    let empty_body = emit_list_arm_body(empty_arm, ctx, body_for_arm(empty_arm));
    let cons_body = emit_list_arm_body(cons_arm, ctx, body_for_arm(cons_arm));
    // Wrap arm bodies in braces only when they contain statements (return, let, etc.)
    // to avoid Rust's "unnecessary braces" warning on simple expressions.
    let wrap = |body: &str| -> String {
        if body.contains("return ") || body.contains("let ") || body.contains(';') {
            format!("{{ {} }}", body)
        } else {
            body.to_string()
        }
    };
    Some(format!(
        "aver_list_match!({}, [] => {}, [{}, {}] => {})",
        subject,
        wrap(&empty_body),
        head_name,
        tail_name,
        wrap(&cons_body)
    ))
}

fn emit_list_match_arms<F>(
    subject_name: &str,
    arms: &[ResolvedMatchArm],
    ctx: &CodegenContext,
    body_for_arm: &F,
) -> String
where
    F: Fn(&ResolvedMatchArm) -> String,
{
    let Some((first, rest)) = arms.split_first() else {
        return "panic!(\"Aver Rust codegen: empty list match\")".to_string();
    };

    let body = emit_list_arm_body(first, ctx, body_for_arm(first));
    let fallback = if rest.is_empty() {
        "panic!(\"Aver Rust codegen: non-exhaustive list match\")".to_string()
    } else {
        emit_list_match_arms(subject_name, rest, ctx, body_for_arm)
    };

    match &first.pattern {
        ResolvedPattern::EmptyList => format!(
            "if {}.is_empty() {{ {} }} else {{ {} }}",
            subject_name, body, fallback
        ),
        ResolvedPattern::Cons(head, tail) => {
            let head_pat = if head == "_" {
                "_".to_string()
            } else {
                aver_name_to_rust(head)
            };
            let tail_pat = if tail == "_" {
                "_".to_string()
            } else {
                aver_name_to_rust(tail)
            };
            format!(
                "if let Some(({}, {})) = aver_rt::list_uncons_cloned(&{}) {{ {} }} else {{ {} }}",
                head_pat, tail_pat, subject_name, body, fallback
            )
        }
        ResolvedPattern::Wildcard => body,
        ResolvedPattern::Ident(name) => {
            let name = aver_name_to_rust(name);
            format!("{{ let {} = {}.clone(); {} }}", name, subject_name, body)
        }
        other => {
            let pat = emit_pattern(other, false, ctx);
            format!(
                "match &{} {{ {} => {{ {} }}, _ => {{ {} }} }}",
                subject_name, pat, body, fallback
            )
        }
    }
}

fn emit_list_arm_body(arm: &ResolvedMatchArm, ctx: &CodegenContext, body: String) -> String {
    let rebindings = emit_pattern_rebindings(&arm.pattern, ctx);
    if rebindings.is_empty() {
        body
    } else {
        format!("{{ {}{} }}", rebindings, body)
    }
}

/// Recursive-position detection for a record/variant constructor:
/// returns the indices of constructor fields whose declared type is
/// the constructor's owning type itself (the boxed-positions a
/// `Tree.Node(left: Tree, value: Int, right: Tree)` lowers under in
/// the Rust backend via `Arc::new(...)` to keep the type sized).
///
/// #180 Phase 7: routes through `find_ctor_owning_type` (which walks
/// `ctx.symbol_table` + `ctx.items` / `ctx.modules`) instead of the
/// legacy `ctx.fn_sigs` keyed by dotted source name. Identity-safe
/// across cross-module same-bare-name twins via `TypeId` equality.
pub(super) fn constructor_boxed_positions(name: &str, ctx: &CodegenContext) -> HashSet<usize> {
    let mut out = HashSet::new();
    let Some(decl) = find_ctor_owning_type(name, ctx) else {
        return out;
    };
    // Bare-name suffix of the owning type — for a dep-module type like
    // `ast.Expr` the field annotation in the .av source is `Expr`, not
    // `ast.Expr`, so the id-less fallback must compare against the
    // bare suffix as well.
    let owning_bare = decl
        .owning_type_name
        .as_deref()
        .map(|n| n.rsplit_once('.').map(|(_, b)| b).unwrap_or(n));
    for (idx, field_ty) in decl.field_types.iter().enumerate() {
        let matches = match (decl.owning_type_id, field_ty.named_id()) {
            (Some(r), Some(p)) => r == p,
            _ => {
                field_ty.named_name() == decl.owning_type_name.as_deref()
                    || field_ty.named_name() == owning_bare
            }
        };
        if matches {
            out.insert(idx);
        }
    }
    out
}

/// Constructor declaration view — the constructor's field types +
/// the canonical identity of the type the constructor belongs to.
/// Built by walking `TypeDef`s in `ctx.items` and dep modules.
struct CtorDecl {
    /// Parsed field types in declaration order. Carry stamped
    /// `Type::Named.id` when the field references a known nominal
    /// type post-resolver — `parse_type_str` reads them off the
    /// source annotation, and `Type::named_id()` reflects whatever
    /// the type-string resolver populated.
    field_types: Vec<crate::types::Type>,
    /// Owning type's `TypeId` (when registered in the symbol
    /// table) — preferred identity primitive for recursive-field
    /// detection.
    owning_type_id: Option<crate::ir::TypeId>,
    /// Owning type's canonical name — fallback identity when
    /// `owning_type_id` isn't stamped (synthetic typedefs, refs not
    /// indexed by the table).
    owning_type_name: Option<String>,
}

fn find_ctor_owning_type(name: &str, ctx: &CodegenContext) -> Option<CtorDecl> {
    use crate::ast::{TopLevel, TypeDef};

    let consider =
        |type_name: &str, ctor_name: &str, fields: Vec<crate::types::Type>| -> CtorDecl {
            let owning_type_id = ctx
                .symbol_table
                .type_id_of(&crate::ir::TypeKey::entry(type_name))
                .or_else(|| {
                    // The bare lookup didn't hit — try as `Module.Name`
                    // for module-scoped types whose key carries an
                    // explicit prefix.
                    type_name.rsplit_once('.').and_then(|(prefix, bare)| {
                        ctx.symbol_table
                            .type_id_of(&crate::ir::TypeKey::in_module(prefix.to_string(), bare))
                    })
                });
            let _ = ctor_name;
            CtorDecl {
                field_types: fields,
                owning_type_id,
                owning_type_name: Some(type_name.to_string()),
            }
        };

    // Constructor name shapes the source may produce:
    //   - `Shape.Circle` (entry sum type)
    //   - `MyModule.Shape.Circle` (module sum type — dotted parent)
    //   - `Box` (entry product / single-ctor type)
    //   - `MyModule.Box` (module product)
    //
    // Walk every typedef across entry + dep modules and match either
    // the bare-name product form or the `parent.variant` sum form.
    let walk_one = |td: &TypeDef, scope: Option<&str>| -> Option<CtorDecl> {
        match td {
            TypeDef::Sum {
                name: parent,
                variants,
                ..
            } => {
                let parent_full = match scope {
                    Some(prefix) => format!("{prefix}.{parent}"),
                    None => parent.clone(),
                };
                for v in variants {
                    let bare_form = format!("{parent}.{}", v.name);
                    let full_form = format!("{parent_full}.{}", v.name);
                    if name == bare_form || name == full_form {
                        let fields = v
                            .fields
                            .iter()
                            .map(|t| crate::types::parse_type_str(t))
                            .collect();
                        return Some(consider(&parent_full, &v.name, fields));
                    }
                }
                None
            }
            TypeDef::Product {
                name: parent,
                fields,
                ..
            } => {
                let parent_full = match scope {
                    Some(prefix) => format!("{prefix}.{parent}"),
                    None => parent.clone(),
                };
                if name == parent || name == parent_full {
                    let fts = fields
                        .iter()
                        .map(|(_, t)| crate::types::parse_type_str(t))
                        .collect();
                    return Some(consider(&parent_full, parent, fts));
                }
                None
            }
        }
    };

    for item in &ctx.items {
        if let TopLevel::TypeDef(td) = item
            && let Some(decl) = walk_one(td, None)
        {
            return Some(decl);
        }
    }
    for m in &ctx.modules {
        for td in &m.type_defs {
            if let Some(decl) = walk_one(td, Some(&m.prefix)) {
                return Some(decl);
            }
        }
    }
    None
}

pub(super) fn constructor_boxed_bindings(
    name: &str,
    bindings: &[String],
    ctx: &CodegenContext,
) -> Vec<String> {
    // `constructor_boxed_positions` walks `TypeDef`s directly post-#180
    // Phase 7, so the dotted-vs-bare ambiguity is resolved by the type
    // walker rather than by canonicalising the constructor name here.
    let boxed = constructor_boxed_positions(name, ctx);
    bindings
        .iter()
        .enumerate()
        .filter_map(|(idx, b)| {
            if b != "_" && boxed.contains(&idx) {
                Some(b.clone())
            } else {
                None
            }
        })
        .collect()
}

/// When matching on a reference (`&T`), pattern bindings are `&Inner`.
/// Emit `let b = b.clone();` for each binding to produce owned values.
fn emit_ref_match_rebindings(pattern: &ResolvedPattern) -> String {
    let bindings = resolved_pattern_bindings(pattern);
    if bindings.is_empty() {
        return String::new();
    }
    let mut lines = Vec::new();
    for b in &bindings {
        let rb = super::syntax::aver_name_to_rust(b);
        lines.push(format!("let {} = {}.clone();", rb, rb));
    }
    format!("{}\n            ", lines.join("\n            "))
}

fn emit_pattern_rebindings(pattern: &ResolvedPattern, ctx: &CodegenContext) -> String {
    let mut lines = Vec::new();
    if let ResolvedPattern::Ctor(ctor, bindings) = pattern {
        // Constructor bindings: only Box-wrapped fields (recursive types) need deref.
        // Look up the canonical "Type.Variant" name from the resolved ctor and feed it
        // to constructor_boxed_bindings, which queries fn_sigs.
        let semantic = semantic_constructor_from_resolved_ctor(ctor, &ctx.symbol_table);
        let ctor_name = match semantic {
            SemanticConstructor::TypeConstructor {
                qualified_type_name,
                variant_name,
            } => format!("{}.{}", qualified_type_name, variant_name),
            SemanticConstructor::Wrapper(_) | SemanticConstructor::NoneValue => {
                // Wrapper / None ctors never carry Box-wrapped recursive fields.
                String::new()
            }
            SemanticConstructor::Unknown(name) => name,
        };
        if !ctor_name.is_empty() {
            for b in constructor_boxed_bindings(&ctor_name, bindings, ctx) {
                let b = aver_name_to_rust(&b);
                lines.push(format!("let {} = (*{}).clone();", b, b));
            }
        }
    }
    if lines.is_empty() {
        String::new()
    } else {
        format!("{}\n            ", lines.join("\n            "))
    }
}

// Suppress unused-import warnings caused by reusing some IR items only in
// specific dispatch paths.
#[allow(dead_code)]
fn _silence_intrinsic_import(_: BuiltinIntrinsic) {}

#[allow(dead_code)]
fn _resolved_to_dotted_unused(expr: &ResolvedExpr) -> Option<String> {
    resolved_to_dotted(expr)
}

#[allow(dead_code)]
fn _thin_kind_unused(_: ThinKind) {}

#[allow(dead_code)]
fn _resolved_stmt_unused(_: &ResolvedStmt) {}