module wasm

import os
import v3.flat
import v3.types

// gen.v is the v3 WebAssembly backend. Like the C backend's FlatGen it walks
// the flat AST directly (WASM has structured control flow, so no SSA/relooping
// is needed), and like the arm64 backend it emits a binary module. Generics,
// strings-as-values, structs, arrays and maps are out of scope for now; the
// backend targets the integer/float core plus WASI `print`/`println`.

// Fixed low-memory scratch layout (bytes):
//   [0..3]   nwritten result for fd_write
//   [4..11]  iovec (ptr @4, len @8)
//   [12]     newline byte '\n'
//   [16..47] itoa scratch buffer (BUF_END = 48, filled back-to-front)
//   [64..]   interned string-literal data
const nwritten_ptr = 0
const iov_ptr = 4
const nl_ptr = 12
const buf_end = 48
const data_base = 64

pub enum WType {
    void
    i32
    i64
    f32
    f64
}

struct FnInfo {
    name    string
    node_id flat.NodeId
    module  string
    file    string
    params  []WType
    ret     WType
    index   int
}

struct Frame {
    tag   FrameTag
    label string // loop label for `break label` / `continue label`, else ''
}

// VarScope snapshots the local-name bindings so an inner block or for-loop can
// shadow an outer local and have the outer binding restored on scope exit.
struct VarScope {
    index    map[string]int
    wtype    map[string]WType
    unsigned map[string]bool
    widths   map[string]int
}

enum FrameTag {
    plain
    brk
    cont
}

@[heap]
pub struct Gen {
mut:
    a        &flat.FlatAst      = unsafe { nil }
    tc       &types.TypeChecker = unsafe { nil }
    used_fns map[string]bool
    mod      &Module = unsafe { nil }
    // per-function state
    cur           Code
    local_types   []u8
    nparams       int
    var_index     map[string]int
    var_wtype     map[string]WType
    var_unsigned  map[string]bool
    var_widths    map[string]int // sub-32-bit int locals: 8 or 16; else 32
    frames        []Frame
    pending_label string // label of a preceding `label:` marker, for the next loop
    cur_ret       WType
    cur_fn_module string
    cur_fn_file   string
    // module-wide; keyed by qualified function name (see qualified_fn_key)
    fn_index        map[string]int
    fn_ret          map[string]WType
    fn_params       map[string][]WType
    file_aliases    map[string]map[string]string // file -> (import alias -> full import path)
    import_paths    []string                     // every `import a.b.c` path (full)
    module_imports  map[string][]string          // module path -> imported module paths ('' = main)
    global_index    map[string]int               // __global name -> wasm global index
    global_wtype    map[string]WType
    global_unsigned map[string]bool
    global_widths   map[string]int
    data_pool       []u8
    data_off        map[string]int
    uses_print      bool
    write_idx       int
    print_int_idx   int
    has_main        bool
    init_fns        []int // function indices of init() entry points, in call order
    warnings        []string
}

pub fn Gen.new(a &flat.FlatAst, tc &types.TypeChecker, used_fns map[string]bool) &Gen {
    return &Gen{
        a:        a
        tc:       tc
        used_fns: used_fns
        mod:      Module.new()
    }
}

// gen builds the whole module from the flat AST.
pub fn (mut g Gen) gen() {
    g.collect_imports()
    g.collect_globals()
    user_fns := g.collect_user_fns()
    g.uses_print = g.detect_print(user_fns)

    // 1. function-index assignment (imports first, then helpers, then user fns).
    mut fd_write_idx := -1
    if g.uses_print {
        ft := g.mod.add_type([valtype_i32, valtype_i32, valtype_i32, valtype_i32], [
            valtype_i32,
        ])
        fd_write_idx = g.mod.add_import_func('wasi_snapshot_preview1', 'fd_write', ft)
    }
    mut defined := 0
    if g.uses_print {
        g.write_idx = g.mod.reserve_func_index(defined)
        defined++
        g.print_int_idx = g.mod.reserve_func_index(defined)
        defined++
    }
    mut module_init := map[string]string{} // module path -> its init fn key
    for i, f in user_fns {
        idx := g.mod.reserve_func_index(defined + i)
        key := qualified_fn_key(f.module, f.name)
        g.fn_index[key] = idx
        g.fn_ret[key] = f.ret
        g.fn_params[key] = f.params
        if f.name == 'main' && (f.module == '' || f.module == 'main') {
            g.has_main = true
        } else if f.name == 'init' && f.params.len == 0 {
            module_init[f.module] = key
        }
    }
    // Order init calls by the import graph (dependencies first), so a module's
    // init observes its imports' startup; main's init runs last.
    mut visited := map[string]bool{}
    g.order_module_inits('', module_init, mut visited)

    // 2. helper bodies (must be added in the same order as reserved above).
    if g.uses_print {
        g.emit_write_helper(fd_write_idx)
        g.emit_print_int_helper()
    }

    // 3. user function bodies.
    for f in user_fns {
        g.emit_user_fn(f)
    }

    // 4. WASI `_start` entry that calls main.
    mut start_idx := -1
    if g.has_main {
        start_idx = g.emit_start()
    }

    // 5. exports + memory sizing + data. WASM export names must be unique, so
    //    reserve the runtime names and skip any user function that would clash.
    g.mod.add_export('memory', export_mem, 0)
    mut used_exports := map[string]bool{}
    used_exports['memory'] = true
    used_exports['_start'] = true
    for f in user_fns {
        ename := export_fn_name(f.module, f.name)
        if ename in used_exports {
            g.warn('not exporting ${f.name}: export name `${ename}` is already in use')
            continue
        }
        used_exports[ename] = true
        g.mod.add_export(ename, export_func, g.fn_index[qualified_fn_key(f.module, f.name)])
    }
    if start_idx >= 0 {
        g.mod.add_export('_start', export_func, start_idx)
    }
    if g.data_pool.len > 0 {
        g.mod.add_data(data_base, g.data_pool)
    }
    if g.uses_print {
        g.mod.add_data(nl_ptr, [u8(0x0a)])
    }
    total := data_base + g.data_pool.len
    pages := if total <= 0x10000 { 2 } else { (total + 0xffff) / 0x10000 + 1 }
    g.mod.set_mem_min(pages)
}

pub fn (g &Gen) warnings_list() []string {
    return g.warnings
}

// write serializes the module to `path`.
pub fn (mut g Gen) write(path string) ! {
    bytes := g.mod.compile()
    os.write_file_array(path, bytes)!
}

// ---- function collection ----

fn (mut g Gen) collect_user_fns() []FnInfo {
    // 1. Gather every candidate (primitive-signature, non-generic) function in
    //    user code, keyed by qualified name, preserving source order.
    mut candidates := map[string]FnInfo{}
    mut order := []string{}
    mut cur_module := ''
    mut cur_file := ''
    mut cur_module_path := ''
    for i in 0 .. g.a.nodes.len {
        node := g.a.nodes[i]
        match node.kind {
            .file {
                cur_module = ''
                cur_file = node.value
                cur_module_path = ''
            }
            .module_decl {
                cur_module = node.value
                // Only files that declare a non-main module are imported modules;
                // resolve their import path. Main files (no decl or `module main`)
                // must never be classified by a directory-name coincidence.
                cur_module_path = if cur_module != '' && cur_module != 'main' {
                    g.module_path_for_file(cur_file)
                } else {
                    ''
                }
            }
            .fn_decl {
                if i < g.a.user_code_start {
                    continue
                }
                if node.generic_params.len > 0 || node.value == '' {
                    continue
                }
                // Prefer the import path (distinguishes same-leaf modules); fall
                // back to the module declaration name if no import matched.
                mod_key := if cur_module_path != '' {
                    cur_module_path
                } else if cur_module != '' && cur_module != 'main' {
                    cur_module
                } else {
                    ''
                }
                if fi := g.fn_info(node, flat.NodeId(i), mod_key, cur_file) {
                    key := qualified_fn_key(mod_key, node.value)
                    if key !in candidates {
                        candidates[key] = fi
                        order << key
                    }
                }
            }
            else {}
        }
    }

    // 2. Seed with every main-module candidate (all of them are compiled and
    //    exported), then BFS-follow direct calls into imported-module
    //    candidates. This deliberately ignores markused reachability: builtins
    //    such as strconv__format_int are intercepted by the print path and
    //    never emitted as real calls, so their numeric helpers must not be
    //    pulled in.
    mut reached := map[string]bool{}
    mut work := []string{}
    for key in order {
        f := candidates[key]
        if f.module == '' || f.module == 'main' {
            reached[key] = true
            work << key
        }
    }
    // `init` functions are entry points (run before main), like the C path's
    // _vinit. Every imported module runs its init regardless of whether any of
    // its other functions are called, so seed the init of main and of every
    // imported module, then follow the calls those inits make.
    mut active := map[string]bool{}
    active[''] = true
    for p in g.import_paths {
        active[p] = true
    }
    for key in order {
        f := candidates[key]
        if key !in reached && f.name == 'init' && f.params.len == 0 && f.module in active {
            reached[key] = true
            work << key
        }
    }
    for work.len > 0 {
        f := candidates[work.pop()]
        for callee_key in g.called_candidate_keys(f, candidates) {
            if callee_key !in reached {
                reached[callee_key] = true
                work << callee_key
            }
        }
    }

    // 3. Emit reached functions in source order for deterministic indices.
    mut out := []FnInfo{}
    for key in order {
        if reached[key] {
            out << candidates[key]
        }
    }
    return out
}

// called_candidate_keys returns the qualified keys of the candidate functions
// directly called inside f's body (calls to non-candidates such as intercepted
// builtins are ignored).
fn (g &Gen) called_candidate_keys(f FnInfo, candidates map[string]FnInfo) []string {
    mut keys := []string{}
    g.collect_call_keys(g.a.nodes[int(f.node_id)], f.module, f.file, candidates, mut keys)
    return keys
}

fn (g &Gen) collect_call_keys(node flat.Node, cur_mod string, cur_file string, candidates map[string]FnInfo, mut keys []string) {
    if node.kind == .call && node.children_count > 0 {
        for key in g.resolve_call_keys(g.a.child_node(&node, 0), cur_mod, cur_file) {
            if key in candidates {
                keys << key
                break
            }
        }
    }
    for i in 0 .. node.children_count {
        cid := g.a.child(&node, i)
        if int(cid) >= 0 {
            g.collect_call_keys(g.a.nodes[int(cid)], cur_mod, cur_file, candidates, mut keys)
        }
    }
}

// fn_info extracts a compilable signature, or none if the function uses types
// the backend does not handle yet (strings, structs, arrays, pointers, ...).
fn (mut g Gen) fn_info(node flat.Node, id flat.NodeId, module_ string, file string) ?FnInfo {
    mut params := []WType{}
    for i in 0 .. node.children_count {
        p := g.a.child_node(&node, i)
        if p.kind != .param || p.value.len == 0 {
            continue
        }
        pt := g.tc.parse_type(p.typ)
        w := prim_wtype(pt) or { return none }
        params << w
    }
    mut ret := WType.void
    if node.typ.len > 0 && node.typ != 'void' {
        rt := g.tc.parse_type(node.typ)
        ret = prim_wtype(rt) or { return none }
    }
    return FnInfo{
        name:    node.value
        node_id: id
        module:  module_
        file:    file
        params:  params
        ret:     ret
    }
}

fn (mut g Gen) detect_print(fns []FnInfo) bool {
    for f in fns {
        node := g.a.nodes[int(f.node_id)]
        if g.subtree_has_print(node) {
            return true
        }
    }
    return false
}

fn (g &Gen) subtree_has_print(node flat.Node) bool {
    if node.kind == .call {
        callee := g.a.child_node(&node, 0)
        if callee.kind == .ident && callee.value in ['println', 'print', 'eprintln', 'eprint'] {
            return true
        }
    }
    for i in 0 .. node.children_count {
        child_id := g.a.child(&node, i)
        if int(child_id) < 0 {
            continue
        }
        if g.subtree_has_print(g.a.nodes[int(child_id)]) {
            return true
        }
    }
    return false
}

// ---- user function emission ----

fn (mut g Gen) emit_user_fn(f FnInfo) {
    node := g.a.nodes[int(f.node_id)]
    g.cur = Code{}
    g.local_types = []u8{}
    g.var_index = map[string]int{}
    g.var_wtype = map[string]WType{}
    g.var_unsigned = map[string]bool{}
    g.var_widths = map[string]int{}
    g.frames = []Frame{}
    g.pending_label = ''
    g.cur_ret = f.ret
    g.cur_fn_module = f.module
    g.cur_fn_file = f.file

    // register params as locals 0..n-1
    mut pi := 0
    mut wparams := []u8{}
    for i in 0 .. node.children_count {
        p := g.a.child_node(&node, i)
        if p.kind != .param || p.value.len == 0 {
            continue
        }
        w := f.params[pi]
        pt := g.tc.parse_type(p.typ)
        g.var_index[p.value] = pi
        g.var_wtype[p.value] = w
        g.var_unsigned[p.value] = type_is_unsigned(pt)
        g.var_widths[p.value] = narrow_width(pt)
        wparams << wt_valtype(w)
        pi++
    }
    g.nparams = pi

    // body: non-param children
    for i in 0 .. node.children_count {
        child := g.a.child_node(&node, i)
        if child.kind == .param {
            continue
        }
        g.gen_stmt(g.a.child(&node, i))
    }
    // A non-void function returns via explicit `return`s; if control still
    // reaches the end (e.g. the body is `if c { return ... } else { return
    // ... }`), the fall-through is unreachable. `unreachable` keeps the stack
    // type-valid without inventing a bogus result value.
    if f.ret != .void {
        g.cur.raw(0x00) // unreachable
    }
    g.cur.end()

    mut results := []u8{}
    if f.ret != .void {
        results << wt_valtype(f.ret)
    }
    type_idx := g.mod.add_type(wparams, results)
    g.mod.add_func(type_idx, g.local_types, g.cur.bytes)
}

fn (mut g Gen) emit_start() int {
    mut c := Code{}
    // Run init() entry points before main, matching the C path's _vinit.
    for init_idx in g.init_fns {
        c.call(init_idx)
    }
    if main_idx := g.fn_index['main'] {
        c.call(main_idx)
    }
    c.end()
    type_idx := g.mod.add_type([], [])
    return g.mod.add_func(type_idx, [], c.bytes)
}

// new_local allocates a fresh local beyond the params and records its type.
fn (mut g Gen) new_local(name string, w WType, unsigned bool, width int) int {
    idx := g.nparams + g.local_types.len
    g.local_types << wt_valtype(w)
    g.var_index[name] = idx
    g.var_wtype[name] = w
    g.var_unsigned[name] = unsigned
    g.var_widths[name] = width
    return idx
}

// alloc_temp allocates an anonymous function-level local (e.g. for the shift
// over-width guard) and returns its index.
fn (mut g Gen) alloc_temp(w WType) int {
    idx := g.nparams + g.local_types.len
    g.local_types << wt_valtype(w)
    return idx
}

// snapshot_scope / restore_scope save and restore local-name bindings so inner
// declarations that shadow an outer local do not leak past their scope.
fn (g &Gen) snapshot_scope() VarScope {
    return VarScope{
        index:    g.var_index.clone()
        wtype:    g.var_wtype.clone()
        unsigned: g.var_unsigned.clone()
        widths:   g.var_widths.clone()
    }
}

fn (mut g Gen) restore_scope(s VarScope) {
    g.var_index = s.index.clone()
    g.var_wtype = s.wtype.clone()
    g.var_unsigned = s.unsigned.clone()
    g.var_widths = s.widths.clone()
}

// ---- statements ----

fn (mut g Gen) gen_stmt(id flat.NodeId) {
    if int(id) < 0 {
        return
    }
    node := g.a.nodes[int(id)]
    if node.kind == .label_stmt {
        // `outer:` marker; attach the label to the next loop. Goto-only markers
        // (outer_break/outer_continue) aren't consumed by a loop and are dropped.
        g.pending_label = node.value
        return
    }
    loop_label := g.pending_label
    g.pending_label = ''
    match node.kind {
        .fn_decl, .c_fn_decl {}
        .block {
            saved := g.snapshot_scope()
            for i in 0 .. node.children_count {
                g.gen_stmt(g.a.child(&node, i))
            }
            g.restore_scope(saved)
        }
        .expr_stmt {
            child_id := g.a.child(&node, 0)
            w := g.gen_expr(child_id)
            if w != .void {
                g.cur.drop()
            }
        }
        .decl_assign {
            g.gen_decl_assign(node)
        }
        .assign, .selector_assign {
            g.gen_assign(node)
        }
        .return_stmt {
            if node.children_count > 0 {
                g.gen_expr_as(g.a.child(&node, 0), g.cur_ret)
            }
            g.cur.ret()
        }
        .if_expr {
            g.gen_if(node)
        }
        .for_stmt {
            g.gen_for(node, loop_label)
        }
        .break_stmt {
            g.gen_branch(node, .brk)
        }
        .continue_stmt {
            g.gen_branch(node, .cont)
        }
        .assert_stmt {
            g.gen_assert(node)
        }
        else {
            g.warn('unsupported statement: ${node.kind}')
        }
    }
}

fn (mut g Gen) gen_decl_assign(node flat.Node) {
    // Multi-declaration (`x, y := a, b`): evaluate every RHS against the outer
    // scope before binding any new name, so a shadowing `x, y := x+1, x+2`
    // reads the outer x for both initializers.
    if node.children_count > 2 {
        g.gen_multi_decl(node)
        return
    }
    lhs := g.a.child_node(&node, 0)
    rhs_id := g.a.child(&node, 1)
    w := g.expr_wtype(rhs_id, node.typ)
    uns := g.decl_is_unsigned(rhs_id, node.typ)
    width := g.decl_width(rhs_id, node.typ)
    if lhs.kind == .ident {
        // Emit the initializer before binding the new name, so a shadowing
        // `x := x + 1` reads the outer x rather than the fresh zero local.
        g.gen_expr_as(rhs_id, w)
        idx := g.new_local(lhs.value, w, uns, width)
        g.narrow_for_local(lhs.value)
        g.cur.local_set(idx)
    }
}

fn (mut g Gen) gen_multi_decl(node flat.Node) {
    mut temps := []int{}
    mut names := []string{}
    mut ws := []WType{}
    mut unss := []bool{}
    mut widths := []int{}
    // Phase 1: buffer every RHS into a temporary (outer bindings still in scope).
    mut i := 0
    for i + 1 < node.children_count {
        lhs := g.a.child_node(&node, i)
        rhs_id := g.a.child(&node, i + 1)
        if lhs.kind == .ident {
            w := g.expr_wtype(rhs_id, node.typ)
            g.gen_expr_as(rhs_id, w)
            t := g.alloc_temp(w)
            g.cur.local_set(t)
            temps << t
            names << lhs.value
            ws << w
            unss << g.decl_is_unsigned(rhs_id, node.typ)
            widths << g.decl_width(rhs_id, node.typ)
        }
        i += 2
    }
    // Phase 2: bind each new local and store its buffered value.
    for k, name in names {
        idx := g.new_local(name, ws[k], unss[k], widths[k])
        g.cur.local_get(temps[k])
        g.narrow_for_local(name)
        g.cur.local_set(idx)
    }
}

fn (mut g Gen) gen_assign(node flat.Node) {
    // Multi-target assignment (`a, b = b, a`): V evaluates every RHS before any
    // store, so buffer them in temporaries first. The transformer normally
    // pre-decomposes these into temp-backed single assigns, so this path is a
    // safeguard rather than the common case.
    if node.op == .assign && node.children_count > 2 {
        g.gen_multi_assign(node)
        return
    }
    mut i := 0
    for i + 1 < node.children_count {
        lhs := g.a.child_node(&node, i)
        rhs_id := g.a.child(&node, i + 1)
        if lhs.kind == .ident && lhs.value == '_' {
            // Blank assignment `_ = expr`: evaluate for side effects, discard.
            w := g.gen_expr(rhs_id)
            if w != .void {
                g.cur.drop()
            }
        } else if lhs.kind == .ident && lhs.value in g.var_index {
            idx := g.var_index[lhs.value]
            w := g.var_wtype[lhs.value]
            if node.op == .assign {
                g.gen_expr_as(rhs_id, w)
            } else {
                op := compound_to_op(node.op)
                signed := !g.var_unsigned[lhs.value]
                g.cur.local_get(idx)
                if op in [.left_shift, .right_shift, .right_shift_unsigned] {
                    // Keep the lhs width; the count may be wider (`x <<= u64(n)`).
                    if op == .right_shift_unsigned && w == .i32 {
                        // `>>>=` shifts the narrow bit pattern; a narrow signed local
                        // is stored sign-extended, so mask it to its width first.
                        lw := g.var_widths[lhs.value]
                        if lw == 8 || lw == 16 {
                            g.emit_narrow(lw, true)
                        }
                    }
                    g.emit_shift_with_count(op, w, rhs_id, signed)
                } else {
                    g.gen_expr_as(rhs_id, w)
                    g.emit_arith(op, w, signed)
                }
            }
            g.narrow_for_local(lhs.value)
            g.cur.local_set(idx)
        } else if lhs.kind == .ident && g.global_key(lhs.value) != '' {
            gkey := g.global_key(lhs.value)
            gidx := g.global_index[gkey]
            w := g.global_wtype[gkey]
            if node.op == .assign {
                g.gen_expr_as(rhs_id, w)
            } else {
                op := compound_to_op(node.op)
                signed := !g.global_unsigned[gkey]
                g.cur.global_get(gidx)
                if op in [.left_shift, .right_shift, .right_shift_unsigned] {
                    if op == .right_shift_unsigned && w == .i32 {
                        lw := g.global_widths[gkey]
                        if lw == 8 || lw == 16 {
                            g.emit_narrow(lw, true)
                        }
                    }
                    g.emit_shift_with_count(op, w, rhs_id, signed)
                } else {
                    g.gen_expr_as(rhs_id, w)
                    g.emit_arith(op, w, signed)
                }
            }
            g.narrow_for_global(gkey)
            g.cur.global_set(gidx)
        } else {
            g.warn('unsupported assign target')
        }
        i += 2
    }
}

// gen_multi_assign evaluates all RHS values into temporaries first, then stores
// each into its target, so `a, b = b, a` swaps instead of clobbering.
fn (mut g Gen) gen_multi_assign(node flat.Node) {
    mut temps := []int{}
    mut targets := []string{} // local name, or global key when is_global
    mut is_global := []bool{}
    mut j := 0
    for j + 1 < node.children_count {
        lhs := g.a.child_node(&node, j)
        rhs_id := g.a.child(&node, j + 1)
        if lhs.kind == .ident && lhs.value != '_' && lhs.value in g.var_index {
            w := g.var_wtype[lhs.value]
            g.gen_expr_as(rhs_id, w)
            t := g.alloc_temp(w)
            g.cur.local_set(t)
            temps << t
            targets << lhs.value
            is_global << false
        } else if lhs.kind == .ident && lhs.value != '_' && g.global_key(lhs.value) != '' {
            gkey := g.global_key(lhs.value)
            w := g.global_wtype[gkey]
            g.gen_expr_as(rhs_id, w)
            t := g.alloc_temp(w)
            g.cur.local_set(t)
            temps << t
            targets << gkey
            is_global << true
        } else {
            // blank or unsupported target: evaluate for side effects, discard
            rw := g.gen_expr(rhs_id)
            if rw != .void {
                g.cur.drop()
            }
        }
        j += 2
    }
    for k, name in targets {
        g.cur.local_get(temps[k])
        if is_global[k] {
            g.narrow_for_global(name)
            g.cur.global_set(g.global_index[name])
        } else {
            g.narrow_for_local(name)
            g.cur.local_set(g.var_index[name])
        }
    }
}

// narrow_for_local masks/sign-extends the value on the stack to the local's
// declared sub-32-bit width before it is stored.
fn (mut g Gen) narrow_for_local(name string) {
    width := g.var_widths[name]
    if width == 8 || width == 16 {
        g.emit_narrow(width, g.var_unsigned[name])
    }
}

fn (mut g Gen) narrow_for_global(key string) {
    width := g.global_widths[key]
    if width == 8 || width == 16 {
        g.emit_narrow(width, g.global_unsigned[key])
    }
}

// global_key resolves a `__global` referenced by bare name from the current
// function to its metadata key, preferring a same-module global and falling
// back to a main-module one, mirroring resolve_call_keys. Globals are keyed by
// module-qualified name, so two modules declaring the same name stay distinct.
// Returns '' when no such global exists.
fn (g &Gen) global_key(name string) string {
    if g.cur_fn_module != '' && g.cur_fn_module != 'main' {
        k := '${g.cur_fn_module}.${name}'
        if k in g.global_index {
            return k
        }
    }
    if name in g.global_index {
        return name
    }
    return ''
}

// decl_width resolves the declared sub-32-bit width (8/16) of an initializer.
fn (mut g Gen) decl_width(rhs_id flat.NodeId, fallback_typ string) int {
    w := narrow_width(g.tc.resolve_type(rhs_id))
    if w != 32 {
        return w
    }
    if fallback_typ.len > 0 {
        return narrow_width(g.tc.parse_type(fallback_typ))
    }
    return 32
}

fn (mut g Gen) gen_if(node flat.Node) {
    cond_id := g.a.child(&node, 0)
    g.gen_expr_as_bool(cond_id)
    g.cur.if_void()
    g.frames << Frame{
        tag: .plain
    }
    then_block := g.a.child_node(&node, 1)
    saved_then := g.snapshot_scope()
    for i in 0 .. then_block.children_count {
        g.gen_stmt(g.a.child(then_block, i))
    }
    g.restore_scope(saved_then)
    if node.children_count > 2 {
        else_id := g.a.child(&node, 2)
        if int(else_id) >= 0 {
            else_node := g.a.nodes[int(else_id)]
            g.cur.else_()
            saved_else := g.snapshot_scope()
            if else_node.kind == .if_expr {
                g.gen_if(else_node)
            } else if else_node.kind == .block {
                for i in 0 .. else_node.children_count {
                    g.gen_stmt(g.a.child(&else_node, i))
                }
            }
            g.restore_scope(saved_else)
        }
    }
    g.cur.end()
    g.frames.pop()
}

fn (mut g Gen) gen_for(node flat.Node, label string) {
    // The initializer and body are scoped to the loop; restore outer bindings
    // afterwards so a shadowing `for i := ...` or body-local does not leak.
    saved := g.snapshot_scope()
    defer {
        g.restore_scope(saved)
    }
    init_node := g.a.child_node(&node, 0)
    cond_id := g.a.child(&node, 1)
    cond_node := g.a.nodes[int(cond_id)]
    post_node := g.a.child_node(&node, 2)

    if init_node.kind != .empty {
        g.gen_stmt(g.a.child(&node, 0))
    }
    // Bindings visible to the condition and post: the loop variable from the
    // initializer, but no body-local shadows.
    header_scope := g.snapshot_scope()
    g.cur.block_void() // break target
    g.frames << Frame{
        tag:   .brk
        label: label
    }
    g.cur.loop_void() // back-edge target
    g.frames << Frame{
        tag: .plain
    }

    if cond_node.kind != .empty {
        g.gen_expr_as_bool(cond_id)
        g.cur.raw(0x45) // i32.eqz
        g.cur.br_if(g.depth_to(.brk))
    }

    g.cur.block_void() // continue target
    g.frames << Frame{
        tag:   .cont
        label: label
    }
    for i in 3 .. node.children_count {
        g.gen_stmt(g.a.child(&node, i))
    }
    g.cur.end()
    g.frames.pop()

    // Drop body-local shadows so the post statement rebinds to the loop var.
    g.restore_scope(header_scope)
    if post_node.kind != .empty {
        g.gen_stmt(g.a.child(&node, 2))
    }
    g.cur.br(g.depth_to_loop())
    g.cur.end() // loop
    g.frames.pop()
    g.cur.end() // block
    g.frames.pop()
}

fn (mut g Gen) gen_branch(node flat.Node, tag FrameTag) {
    if node.value.len > 0 {
        // `break label` / `continue label`: target the labeled loop's frame.
        g.cur.br(g.depth_to_labeled(tag, node.value))
    } else {
        g.cur.br(g.depth_to(tag))
    }
}

fn (mut g Gen) gen_assert(node flat.Node) {
    if node.children_count == 0 {
        return
    }
    g.gen_expr_as_bool(g.a.child(&node, 0))
    g.cur.raw(0x45) // i32.eqz
    g.cur.if_void()
    g.cur.raw(0x00) // unreachable -> trap
    g.cur.end()
}

// depth_to returns the relative br depth to the nearest enclosing frame tagged
// `tag`, counted from the current (innermost) frame.
fn (g &Gen) depth_to(tag FrameTag) int {
    for i := g.frames.len - 1; i >= 0; i-- {
        if g.frames[i].tag == tag {
            return (g.frames.len - 1) - i
        }
    }
    return 0
}

// depth_to_labeled finds the nearest frame with the given tag and loop label
// (for `break label` / `continue label`), falling back to the nearest tag.
fn (g &Gen) depth_to_labeled(tag FrameTag, label string) int {
    for i := g.frames.len - 1; i >= 0; i-- {
        if g.frames[i].tag == tag && g.frames[i].label == label {
            return (g.frames.len - 1) - i
        }
    }
    return g.depth_to(tag)
}

// depth_to_loop returns the depth of the nearest `.plain` loop frame. Loop and
// if frames are both `.plain`; the back-edge target is the most recent one that
// is not the continue block, which by construction is the loop directly below
// the continue frame. We resolve it as the nearest `.plain` frame.
fn (g &Gen) depth_to_loop() int {
    for i := g.frames.len - 1; i >= 0; i-- {
        if g.frames[i].tag == .plain {
            return (g.frames.len - 1) - i
        }
    }
    return 0
}

// ---- expressions ----

// gen_expr emits code that pushes the value of `id` and returns its WType
// (`.void` if nothing was pushed).
fn (mut g Gen) gen_expr(id flat.NodeId) WType {
    if int(id) < 0 {
        g.cur.i32_const(0)
        return .i32
    }
    node := g.a.nodes[int(id)]
    match node.kind {
        .int_literal {
            val := parse_int_literal(node.value)
            mut w := g.expr_wtype(id, '')
            // Promote to i64 when the literal does not fit in i32: the checker
            // types untyped literals as plain `int`, which would truncate.
            if w == .i32 && (val > 2147483647 || val < -2147483648) {
                w = .i64
            }
            if w == .i64 {
                g.cur.i64_const(val)
                return .i64
            }
            g.cur.i32_const(val)
            return .i32
        }
        .bool_literal {
            g.cur.i32_const(if node.value == 'true' { 1 } else { 0 })
            return .i32
        }
        .char_literal {
            // `A` etc. is a scalar (u8/rune); emit its code value.
            g.cur.i32_const(char_literal_value(node.value))
            return .i32
        }
        .float_literal {
            w := g.expr_wtype(id, '')
            fv := node.value.replace('_', '').f64()
            if w == .f32 {
                g.cur.f32_const(f32(fv))
                return .f32
            }
            g.cur.f64_const(fv)
            return .f64
        }
        .ident {
            if node.value in g.var_index {
                g.cur.local_get(g.var_index[node.value])
                return g.var_wtype[node.value]
            }
            gkey := g.global_key(node.value)
            if gkey != '' {
                g.cur.global_get(g.global_index[gkey])
                return g.global_wtype[gkey]
            }
            // Top-level consts are inlined from their recorded value expression.
            if cid := g.const_value_node(node.value) {
                return g.gen_expr(cid)
            }
            g.warn('unknown ident: ${node.value}')
            g.cur.i32_const(0)
            return .i32
        }
        .paren {
            return g.gen_expr(g.a.child(&node, 0))
        }
        .cast_expr {
            return g.gen_cast(node)
        }
        .infix {
            return g.gen_infix(id, node)
        }
        .prefix {
            return g.gen_prefix(id, node)
        }
        .postfix {
            g.gen_postfix(node)
            return .void
        }
        .call {
            return g.gen_call(node)
        }
        .if_expr {
            return g.gen_if_value(id, node)
        }
        .selector {
            // An imported-module const is accessed as `mod.name`; inline it.
            if cid := g.selector_const_node(node) {
                return g.gen_expr(cid)
            }
            g.warn('unsupported selector: ${node.value}')
            g.cur.i32_const(0)
            return .i32
        }
        else {
            g.warn('unsupported expr: ${node.kind}')
            g.cur.i32_const(0)
            return .i32
        }
    }
}

// selector_const_node resolves a `module.name` selector to a top-level const's
// value expression. v3 keys module consts by the module declaration name, so we
// try the literal base, the resolved import path and its last component, then
// the bare field name as an unambiguous suffix.
fn (g &Gen) selector_const_node(node flat.Node) ?flat.NodeId {
    if node.children_count == 0 {
        return none
    }
    base := g.a.child_node(&node, 0)
    if base.kind != .ident {
        return none
    }
    field := node.value
    real := g.resolve_module_alias(g.cur_fn_file, base.value)
    for modname in [base.value, real, real.all_after_last('.')] {
        if cid := g.const_value_node('${modname}.${field}') {
            return cid
        }
    }
    return g.const_value_node(field)
}

// const_value_node resolves an identifier to the value expression of a
// top-level const, if any (numeric/bool consts are inlined at the use site).
fn (g &Gen) const_value_node(name string) ?flat.NodeId {
    if cid := g.tc.const_exprs[name] {
        return cid
    }
    if key := g.tc.const_suffixes[name] {
        if key.len > 0 {
            if cid := g.tc.const_exprs[key] {
                return cid
            }
        }
    }
    return none
}

// gen_if_value emits an `if` used as an expression, leaving the selected
// branch's value on the stack (e.g. `x := if c { 1 } else { 2 }`).
fn (mut g Gen) gen_if_value(id flat.NodeId, node flat.Node) WType {
    result_w := g.expr_wtype(id, '')
    g.gen_if_value_typed(node, result_w)
    return result_w
}

fn (mut g Gen) gen_if_value_typed(node flat.Node, result_w WType) {
    g.gen_expr_as_bool(g.a.child(&node, 0))
    g.cur.raw(0x04) // if
    g.cur.raw(wt_valtype(result_w)) // result type
    g.frames << Frame{
        tag: .plain
    }
    g.gen_block_value(g.a.child_node(&node, 1), result_w)
    g.cur.else_()
    if node.children_count > 2 {
        else_id := g.a.child(&node, 2)
        else_node := g.a.nodes[int(else_id)]
        if else_node.kind == .if_expr {
            g.gen_if_value_typed(else_node, result_w)
        } else if else_node.kind == .block {
            g.gen_block_value(else_node, result_w)
        } else {
            g.push_zero(result_w)
        }
    } else {
        // A value `if` requires an else; keep the stack typed otherwise.
        g.push_zero(result_w)
    }
    g.cur.end()
    g.frames.pop()
}

// gen_block_value emits a block's statements, leaving the value of its trailing
// expression on the stack, coerced to result_w.
fn (mut g Gen) gen_block_value(block flat.Node, result_w WType) {
    saved := g.snapshot_scope()
    n := int(block.children_count)
    for i in 0 .. n - 1 {
        g.gen_stmt(g.a.child(&block, i))
    }
    if n > 0 {
        last_id := g.a.child(&block, n - 1)
        last := g.a.nodes[int(last_id)]
        if last.kind == .expr_stmt {
            g.gen_expr_as(g.a.child(&last, 0), result_w)
        } else if last.kind == .if_expr {
            g.gen_if_value_typed(last, result_w)
        } else {
            g.gen_stmt(last_id)
            g.push_zero(result_w)
        }
    } else {
        g.push_zero(result_w)
    }
    g.restore_scope(saved)
}

fn (mut g Gen) push_zero(w WType) {
    match w {
        .i64 { g.cur.i64_const(0) }
        .f64 { g.cur.f64_const(0) }
        .f32 { g.cur.f32_const(0) }
        else { g.cur.i32_const(0) }
    }
}

// gen_expr_as emits `id` coerced to the target WType.
fn (mut g Gen) gen_expr_as(id flat.NodeId, target WType) {
    w := g.gen_expr(id)
    if target == .void || w == .void {
        return
    }
    g.coerce(w, target, g.is_signed(id))
}

// gen_expr_as_bool emits `id` leaving an i32 truth value on the stack.
fn (mut g Gen) gen_expr_as_bool(id flat.NodeId) {
    w := g.gen_expr(id)
    if w == .i64 {
        g.cur.i64_const(0)
        g.cur.raw(0x52) // i64.ne -> i32
    } else if w == .f64 {
        g.cur.f64_const(0)
        g.cur.raw(0x62) // f64.ne
    } else if w == .f32 {
        g.cur.f32_const(0)
        g.cur.raw(0x5c) // f32.ne
    }
    // i32 already a truth value
}

fn (mut g Gen) gen_infix(id flat.NodeId, node flat.Node) WType {
    lhs_id := g.a.child(&node, 0)
    rhs_id := g.a.child(&node, 1)
    op := node.op
    if op == .logical_and || op == .logical_or {
        return g.gen_logical(node)
    }
    if op in [.eq, .ne, .lt, .gt, .le, .ge] {
        ow := g.operand_wtype(lhs_id, rhs_id)
        // Mixed signed/unsigned integer comparisons compare mathematical values,
        // not bit patterns, so a negative signed operand needs special handling.
        if ow in [WType.i32, WType.i64] && g.is_unsigned(lhs_id) != g.is_unsigned(rhs_id) {
            g.gen_mixed_cmp(lhs_id, rhs_id, op, ow)
            return .i32
        }
        signed := !g.is_unsigned(lhs_id) && !g.is_unsigned(rhs_id)
        g.gen_expr_as(lhs_id, ow)
        g.gen_expr_as(rhs_id, ow)
        g.cur.raw(cmp_op(op, ow, signed))
        return .i32
    }
    if op in [.left_shift, .right_shift, .right_shift_unsigned] {
        // V keeps the result type/width from the left operand and permits a
        // wider shift count, so the width comes from the lhs, not both operands.
        mut value_w := g.expr_wtype(lhs_id, '')
        if value_w !in [WType.i32, WType.i64] {
            value_w = .i32
        }
        signed := !g.is_unsigned(lhs_id)
        g.gen_expr_as(lhs_id, value_w)
        if op == .right_shift_unsigned && value_w == .i32 {
            // `>>>` operates on the narrow bit pattern; a narrow signed lhs is
            // stored sign-extended, so mask it to its width first.
            lw := narrow_width(g.tc.resolve_type(lhs_id))
            if lw != 32 {
                g.emit_narrow(lw, true)
            }
        }
        g.emit_shift_with_count(op, value_w, rhs_id, signed)
        if value_w == .i32 {
            g.narrow_result(id)
        }
        return value_w
    }
    // arithmetic / bitwise: in V both operands share the result type, so combine
    // the node's own type with the operand-derived width (the latter recovers
    // i64/float when the node type is missing).
    ow := combine_wtype(g.expr_wtype(id, node.typ), g.operand_wtype(lhs_id, rhs_id))
    // div/rem opcode signedness must follow the promoted result, so an unsigned
    // operand (e.g. `4000000000 / u32(2)`) selects div_u/rem_u, not the lhs.
    signed := !g.is_unsigned(id) && !g.is_unsigned(lhs_id) && !g.is_unsigned(rhs_id)
    g.gen_expr_as(lhs_id, ow)
    g.gen_expr_as(rhs_id, ow)
    g.emit_arith(op, ow, signed)
    // Sub-32-bit results (e.g. u8 + u8) wrap to their declared width in V.
    if ow == .i32 {
        g.narrow_result(id)
    }
    return ow
}

// narrow_result masks/sign-extends the i32 on the stack to the resolved type's
// sub-32-bit width (a no-op for 32/64-bit types).
fn (mut g Gen) narrow_result(id flat.NodeId) {
    rt := g.tc.resolve_type(id)
    g.emit_narrow(narrow_width(rt), type_is_unsigned(rt))
}

fn (mut g Gen) gen_logical(node flat.Node) WType {
    lhs_id := g.a.child(&node, 0)
    rhs_id := g.a.child(&node, 1)
    g.gen_expr_as_bool(lhs_id)
    g.cur.raw(0x04) // if
    g.cur.raw(valtype_i32) // -> i32 result
    g.frames << Frame{
        tag: .plain
    }
    if node.op == .logical_and {
        g.gen_expr_as_bool(rhs_id)
        g.cur.else_()
        g.cur.i32_const(0)
    } else {
        g.cur.i32_const(1)
        g.cur.else_()
        g.gen_expr_as_bool(rhs_id)
    }
    g.cur.end()
    g.frames.pop()
    return .i32
}

// gen_mixed_cmp emits a comparison of a signed and an unsigned integer operand
// by mathematical value. The two operands are buffered, then: if the signed
// operand is negative it is smaller than the (non-negative) unsigned operand,
// otherwise both are non-negative and an unsigned comparison is exact.
fn (mut g Gen) gen_mixed_cmp(lhs_id flat.NodeId, rhs_id flat.NodeId, op flat.Op, ow WType) {
    lhs_signed := !g.is_unsigned(lhs_id)
    lhs_tmp := g.alloc_temp(ow)
    rhs_tmp := g.alloc_temp(ow)
    g.gen_expr_as(lhs_id, ow)
    g.cur.local_set(lhs_tmp)
    g.gen_expr_as(rhs_id, ow)
    g.cur.local_set(rhs_tmp)
    // is the signed operand negative?
    g.cur.local_get(if lhs_signed { lhs_tmp } else { rhs_tmp })
    if ow == .i64 {
        g.cur.i64_const(0)
        g.cur.raw(0x53) // i64.lt_s
    } else {
        g.cur.i32_const(0)
        g.cur.raw(0x48) // i32.lt_s
    }
    g.cur.raw(0x04) // if
    g.cur.raw(valtype_i32) // -> i32
    g.frames << Frame{
        tag: .plain
    }
    g.cur.i32_const(neg_signed_cmp_result(op, lhs_signed))
    g.cur.else_()
    g.cur.local_get(lhs_tmp)
    g.cur.local_get(rhs_tmp)
    g.cur.raw(cmp_op(op, ow, false)) // both non-negative: unsigned comparison
    g.cur.end()
    g.frames.pop()
}

// neg_signed_cmp_result is the comparison result when the signed operand is
// negative and the other operand is unsigned (hence non-negative), so the
// signed operand is strictly the smaller value.
fn neg_signed_cmp_result(op flat.Op, signed_is_lhs bool) int {
    return match op {
        .lt, .le {
            if signed_is_lhs {
                1
            } else {
                0
            }
        }
        .gt, .ge {
            if signed_is_lhs {
                0
            } else {
                1
            }
        }
        .eq {
            0
        }
        .ne {
            1
        }
        else {
            0
        }
    }
}

fn (mut g Gen) gen_prefix(id flat.NodeId, node flat.Node) WType {
    child_id := g.a.child(&node, 0)
    match node.op {
        .minus {
            child := g.a.nodes[int(child_id)]
            if child.kind == .int_literal {
                // Fold `-literal` directly: the checker may type a large literal
                // as plain int, which would wrap the magnitude to 32 bits before
                // negating (e.g. i64(-9223372036854775808)).
                mag := u64(parse_int_literal(child.value))
                if mag > 2147483648 {
                    g.cur.i64_const(i64(u64(0) - mag))
                    return .i64
                }
                g.cur.i32_const(-i64(mag))
                g.narrow_result(id)
                return .i32
            }
            w := g.expr_wtype(child_id, '')
            match w {
                .f64 {
                    g.gen_expr(child_id)
                    g.cur.raw(0x9a) // f64.neg
                    return .f64
                }
                .f32 {
                    g.gen_expr(child_id)
                    g.cur.raw(0x8c) // f32.neg
                    return .f32
                }
                .i64 {
                    g.cur.i64_const(0)
                    g.gen_expr_as(child_id, .i64)
                    g.cur.raw(0x7d) // i64.sub
                    return .i64
                }
                else {
                    g.cur.i32_const(0)
                    g.gen_expr_as(child_id, .i32)
                    g.cur.raw(0x6b) // i32.sub
                    g.narrow_result(id) // negation of a narrow type wraps to its width
                    return .i32
                }
            }
        }
        .not {
            g.gen_expr_as_bool(child_id)
            g.cur.raw(0x45) // i32.eqz
            return .i32
        }
        .bit_not {
            w := g.gen_expr(child_id)
            if w == .i64 {
                g.cur.i64_const(-1)
                g.cur.raw(0x85) // i64.xor
                return .i64
            }
            g.cur.i32_const(-1)
            g.cur.raw(0x73) // i32.xor
            g.narrow_result(id) // ~ of a narrow type keeps its width (e.g. ~u8(0)=255)
            return .i32
        }
        else {
            g.warn('unsupported prefix op: ${node.op}')
            return g.gen_expr(child_id)
        }
    }
}

fn (mut g Gen) gen_postfix(node flat.Node) {
    target := g.a.child_node(&node, 0)
    inc := node.op == .inc
    if target.kind == .ident && target.value in g.var_index {
        idx := g.var_index[target.value]
        g.cur.local_get(idx)
        g.emit_inc(g.var_wtype[target.value], inc)
        g.narrow_for_local(target.value)
        g.cur.local_set(idx)
        return
    }
    if target.kind == .ident {
        gkey := g.global_key(target.value)
        if gkey != '' {
            gidx := g.global_index[gkey]
            g.cur.global_get(gidx)
            g.emit_inc(g.global_wtype[gkey], inc)
            g.narrow_for_global(gkey)
            g.cur.global_set(gidx)
            return
        }
    }
    g.warn('unsupported postfix target')
}

// emit_inc pushes 1 of the given type and adds (inc) or subtracts it from the
// value already on the stack, used by `x++`/`x--` for locals and globals.
fn (mut g Gen) emit_inc(w WType, inc bool) {
    match w {
        .i64 {
            g.cur.i64_const(1)
            g.cur.raw(if inc { u8(0x7c) } else { u8(0x7d) }) // i64.add/sub
        }
        .f64 {
            g.cur.f64_const(1)
            g.cur.raw(if inc { u8(0xa0) } else { u8(0xa1) }) // f64.add/sub
        }
        .f32 {
            g.cur.f32_const(1)
            g.cur.raw(if inc { u8(0x92) } else { u8(0x93) }) // f32.add/sub
        }
        else {
            g.cur.i32_const(1)
            g.cur.raw(if inc { u8(0x6a) } else { u8(0x6b) }) // i32.add/sub
        }
    }
}

fn (mut g Gen) gen_cast(node flat.Node) WType {
    child_id := g.a.child(&node, 0)
    tt := g.tc.parse_type(node.value)
    target := prim_wtype(tt) or { WType.i32 }
    child := g.a.nodes[int(child_id)]
    if target in [WType.f32, WType.f64] && child.kind == .int_literal {
        // Materialize the literal directly for the float target: an integer
        // path would wrap large non-negative values (e.g.
        // f64(9223372036854775808)) before the conversion and flip the sign.
        uval := u64(parse_int_literal(child.value))
        if target == .f32 {
            g.cur.f32_const(f32(uval))
        } else {
            g.cur.f64_const(f64(uval))
        }
        return target
    }
    src := g.gen_expr(child_id)
    if src in [WType.f32, WType.f64] && target in [WType.i32, WType.i64] {
        // float -> int: signedness comes from the target, not the source.
        g.emit_float_to_int(src, target, !type_is_unsigned(tt))
    } else {
        g.coerce(src, target, g.is_signed(child_id))
    }
    // Casting to a sub-32-bit type wraps/sign-extends to that width.
    g.emit_narrow(narrow_width(tt), type_is_unsigned(tt))
    return target
}

fn (mut g Gen) gen_call(node flat.Node) WType {
    callee := g.a.child_node(&node, 0)
    if callee.kind == .ident && callee.value in ['println', 'print', 'eprintln', 'eprint'] {
        g.gen_print_call(node, callee.value)
        return .void
    }
    for key in g.resolve_call_keys(callee, g.cur_fn_module, g.cur_fn_file) {
        if key in g.fn_index {
            params := g.fn_params[key]
            for i in 1 .. node.children_count {
                pw := if i - 1 < params.len { params[i - 1] } else { WType.i32 }
                g.gen_expr_as(g.a.child(&node, i), pw)
            }
            g.cur.call(g.fn_index[key])
            return g.fn_ret[key]
        }
    }
    if callee.kind == .ident {
        g.warn('unsupported call: ${callee.value}')
    } else {
        g.warn('unsupported call target')
    }
    // keep the stack balanced for value contexts
    g.cur.i32_const(0)
    return .i32
}

// collect_imports records every import path and, per source file, the
// selector/alias -> full import path mapping. Candidates are keyed by the full
// import path (see module_path_for_file), so two nested modules with the same
// leaf (`import foo.util as fu`, `import bar.util as bu`) stay distinct.
fn (mut g Gen) collect_imports() {
    // Pass 1: import paths + per-file aliases.
    mut cur_file := ''
    for node in g.a.nodes {
        if node.kind == .file {
            cur_file = node.value
        } else if node.kind == .import_decl && node.value.len > 0 {
            g.import_paths << node.value
            if node.typ.len > 0 {
                if cur_file !in g.file_aliases {
                    g.file_aliases[cur_file] = map[string]string{}
                }
                g.file_aliases[cur_file][node.typ] = node.value
            }
        }
    }
    // Pass 2: the module import graph (module_path_for_file now works), keyed by
    // the importing file's module path ('' for main), used to order init calls.
    cur_file = ''
    mut cur_mod := ''
    for node in g.a.nodes {
        if node.kind == .file {
            cur_file = node.value
            cur_mod = ''
        } else if node.kind == .module_decl {
            cur_mod = if node.value != '' && node.value != 'main' {
                g.module_path_for_file(cur_file)
            } else {
                ''
            }
        } else if node.kind == .import_decl && node.value.len > 0 {
            g.module_imports[cur_mod] << node.value
        }
    }
}

// collect_globals lowers primitive `__global` declarations to mutable wasm
// globals, recording each name's index/type and emitting a constant initializer.
fn (mut g Gen) collect_globals() {
    mut cur_module := ''
    mut cur_file := ''
    mut cur_module_path := ''
    for i in 0 .. g.a.nodes.len {
        node := g.a.nodes[i]
        if node.kind == .file {
            cur_module = ''
            cur_file = node.value
            cur_module_path = ''
            continue
        }
        if node.kind == .module_decl {
            cur_module = node.value
            cur_module_path = if cur_module != '' && cur_module != 'main' {
                g.module_path_for_file(cur_file)
            } else {
                ''
            }
            continue
        }
        if node.kind != .global_decl || i < g.a.user_code_start {
            continue
        }
        // Qualify the global by its declaring module so a name declared in two
        // modules maps to two distinct wasm globals (see global_key for lookup).
        mod_key := if cur_module_path != '' {
            cur_module_path
        } else if cur_module != '' && cur_module != 'main' {
            cur_module
        } else {
            ''
        }
        for fi in 0 .. node.children_count {
            f := g.a.child_node(&node, fi)
            if f.kind != .field_decl || f.value.len == 0 || f.value.starts_with('C.') {
                continue
            }
            // Type from the declaration, or inferred from the initializer.
            mut t := types.Type(types.Void{})
            if f.typ.len > 0 {
                t = g.tc.parse_type(f.typ)
            } else if f.children_count > 0 {
                t = g.tc.resolve_type(g.a.child(f, 0))
            }
            w := prim_wtype(t) or { continue } // only numeric/bool globals
            width := narrow_width(t)
            unsigned := type_is_unsigned(t)
            mut init := Code{}
            if f.children_count > 0 {
                g.emit_global_init(g.a.child(f, 0), w, width, unsigned, mut init)
            } else {
                init_push_zero(w, mut init)
            }
            init.end()
            gidx := g.mod.add_global(wt_valtype(w), init.bytes)
            key := qualified_fn_key(mod_key, f.value)
            g.global_index[key] = gidx
            g.global_wtype[key] = w
            g.global_unsigned[key] = unsigned
            g.global_widths[key] = width
        }
    }
}

// emit_global_init writes a constant initializer expression for a global. Only
// constant literals (optionally negated/cast) are folded; others default to 0.
fn (g &Gen) emit_global_init(init_id flat.NodeId, w WType, width int, unsigned bool, mut c Code) {
    if w in [WType.f32, WType.f64] {
        fv := g.fold_const_float(init_id)
        if w == .f32 {
            c.f32_const(f32(fv))
        } else {
            c.f64_const(fv)
        }
        return
    }
    iv := g.fold_const_int(init_id)
    if w == .i64 {
        c.i64_const(iv)
    } else {
        // Apply the global's declared sub-32-bit width so an out-of-range cast
        // initializer (e.g. `u8(300)` -> 44, `i8(128)` -> -128) matches what a
        // later store would narrow it to via narrow_for_global.
        c.i32_const(narrow_const(iv, width, unsigned))
    }
}

// narrow_const wraps/sign-extends a constant to a declared 8/16-bit width; the
// compile-time counterpart of emit_narrow.
fn narrow_const(v i64, width int, unsigned bool) i64 {
    return match width {
        8 {
            if unsigned {
                i64(u8(v))
            } else {
                i64(i8(v))
            }
        }
        16 {
            if unsigned {
                i64(u16(v))
            } else {
                i64(i16(v))
            }
        }
        else {
            v
        }
    }
}

fn (g &Gen) fold_const_int(id flat.NodeId) i64 {
    if int(id) < 0 {
        return 0
    }
    n := g.a.nodes[int(id)]
    match n.kind {
        .int_literal {
            return parse_int_literal(n.value)
        }
        .char_literal {
            return char_literal_value(n.value)
        }
        .bool_literal {
            return if n.value == 'true' { i64(1) } else { i64(0) }
        }
        .ident {
            // A constant referenced by name folds to its own constant value.
            if cid := g.const_value_node(n.value) {
                return g.fold_const_int(cid)
            }
        }
        .prefix {
            if n.children_count > 0 {
                match n.op {
                    .minus { return -g.fold_const_int(g.a.child(&n, 0)) }
                    .bit_not { return ~g.fold_const_int(g.a.child(&n, 0)) }
                    else {}
                }
            }
        }
        .infix {
            if n.children_count >= 2 {
                // Narrow to the infix's own resolved type so any wrapping happens
                // before a wider outer cast can observe it, matching normal codegen
                // (`int(u8(250) + u8(10))` -> 4, not 260).
                return narrow_to_type(g.fold_const_infix(n), g.tc.resolve_type(id))
            }
        }
        .paren {
            if n.children_count > 0 {
                return g.fold_const_int(g.a.child(&n, 0))
            }
        }
        .cast_expr {
            if n.children_count > 0 {
                cv := g.fold_const_int(g.a.child(&n, 0))
                // Apply the cast target's own width/signedness so a nested narrow
                // cast keeps its value even when the enclosing global is wider
                // (e.g. `int(u8(300))` -> 44, not 300).
                return if n.value.len > 0 { g.fold_cast_int(cv, n.value) } else { cv }
            }
        }
        else {}
    }

    return 0
}

// fold_const_infix folds a binary constant expression (`1 + 2`, `base << 3`, ...)
// over its already-folded integer operands. Division, remainder, right shift and
// comparisons use unsigned semantics when either operand resolves to an unsigned
// type, since folded operands are stored as i64 bit patterns (u64(max) -> -1) and
// signed ops would otherwise mis-fold, e.g. `u64(max) / u64(2)`.
fn (g &Gen) fold_const_infix(n flat.Node) i64 {
    la := g.a.child(&n, 0)
    lb := g.a.child(&n, 1)
    a := g.fold_const_int(la)
    b := g.fold_const_int(lb)
    unsigned := type_is_unsigned(g.tc.resolve_type(la)) || type_is_unsigned(g.tc.resolve_type(lb))
    return match n.op {
        .plus {
            a + b
        }
        .minus {
            a - b
        }
        .mul {
            a * b
        }
        .div {
            if b == 0 {
                i64(0)
            } else if unsigned {
                i64(u64(a) / u64(b))
            } else {
                a / b
            }
        }
        .mod {
            if b == 0 {
                i64(0)
            } else if unsigned {
                i64(u64(a) % u64(b))
            } else {
                a % b
            }
        }
        .amp {
            a & b
        }
        .pipe {
            a | b
        }
        .xor {
            a ^ b
        }
        .left_shift {
            i64(u64(a) << b)
        }
        .right_shift {
            if unsigned {
                i64(u64(a) >> b)
            } else {
                a >> b
            }
        }
        .right_shift_unsigned {
            i64(u64(a) >> b)
        }
        .eq {
            bool_to_i64(a == b)
        }
        .ne {
            bool_to_i64(a != b)
        }
        .lt {
            if unsigned {
                bool_to_i64(u64(a) < u64(b))
            } else {
                bool_to_i64(a < b)
            }
        }
        .gt {
            if unsigned {
                bool_to_i64(u64(a) > u64(b))
            } else {
                bool_to_i64(a > b)
            }
        }
        .le {
            if unsigned {
                bool_to_i64(u64(a) <= u64(b))
            } else {
                bool_to_i64(a <= b)
            }
        }
        .ge {
            if unsigned {
                bool_to_i64(u64(a) >= u64(b))
            } else {
                bool_to_i64(a >= b)
            }
        }
        else {
            i64(0)
        }
    }
}

fn bool_to_i64(b bool) i64 {
    return if b { i64(1) } else { i64(0) }
}

// fold_cast_int wraps a folded constant to a numeric cast target's width and
// signedness, the compile-time form of gen_cast's narrowing.
fn (g &Gen) fold_cast_int(v i64, type_name string) i64 {
    return narrow_to_type(v, g.tc.parse_type(type_name))
}

// narrow_to_type wraps a folded constant to an integer type's width and
// signedness (i64 targets keep the full value; i32-family targets wrap to
// 8/16/32 bits; non-integer targets are left unchanged).
fn narrow_to_type(v i64, t types.Type) i64 {
    w := prim_wtype(t) or { return v }
    if w != .i32 {
        return v
    }
    unsigned := type_is_unsigned(t)
    return match narrow_width(t) {
        8 {
            if unsigned {
                i64(u8(v))
            } else {
                i64(i8(v))
            }
        }
        16 {
            if unsigned {
                i64(u16(v))
            } else {
                i64(i16(v))
            }
        }
        else {
            if unsigned {
                i64(u32(v))
            } else {
                i64(i32(v))
            }
        }
    }
}

fn (g &Gen) fold_const_float(id flat.NodeId) f64 {
    if int(id) < 0 {
        return 0
    }
    n := g.a.nodes[int(id)]
    match n.kind {
        .float_literal {
            return n.value.replace('_', '').f64()
        }
        .int_literal {
            return f64(parse_int_literal(n.value))
        }
        .ident {
            if cid := g.const_value_node(n.value) {
                return g.fold_const_float(cid)
            }
        }
        .prefix {
            if n.op == .minus && n.children_count > 0 {
                return -g.fold_const_float(g.a.child(&n, 0))
            }
        }
        .infix {
            if n.children_count >= 2 {
                a := g.fold_const_float(g.a.child(&n, 0))
                b := g.fold_const_float(g.a.child(&n, 1))
                return match n.op {
                    .plus {
                        a + b
                    }
                    .minus {
                        a - b
                    }
                    .mul {
                        a * b
                    }
                    .div {
                        if b != 0 {
                            a / b
                        } else {
                            f64(0)
                        }
                    }
                    else {
                        f64(0)
                    }
                }
            }
        }
        .paren {
            if n.children_count > 0 {
                return g.fold_const_float(g.a.child(&n, 0))
            }
        }
        .cast_expr {
            if n.children_count > 0 {
                cid := g.a.child(&n, 0)
                tw := prim_wtype(g.tc.parse_type(n.value)) or { WType.f64 }
                if tw !in [WType.f32, WType.f64] {
                    // Cast to an integer type inside a float context: fold and
                    // narrow as an int, then widen to float.
                    return f64(g.fold_cast_int(g.fold_const_int(cid), n.value))
                }
                child := g.a.nodes[int(cid)]
                mut fv := if child.kind == .int_literal {
                    // Match gen_cast: reinterpret the literal's wrapped i64 bits as
                    // u64 so a large non-negative literal (e.g.
                    // f64(9223372036854775808)) stays positive instead of flipping
                    // sign through parse_int_literal.
                    f64(u64(parse_int_literal(child.value)))
                } else {
                    g.fold_const_float(cid)
                }
                if tw == .f32 {
                    fv = f64(f32(fv)) // round to f32 precision like an f32 cast
                }
                return fv
            }
        }
        else {}
    }

    return 0
}

fn init_push_zero(w WType, mut c Code) {
    match w {
        .i64 { c.i64_const(0) }
        .f64 { c.f64_const(0) }
        .f32 { c.f32_const(0) }
        else { c.i32_const(0) }
    }
}

// order_module_inits appends init function indices in dependency order via a
// post-order walk of the import graph: a module's imports' inits run first, and
// since main ('') is the root, its own init is appended last.
fn (mut g Gen) order_module_inits(mod string, module_init map[string]string, mut visited map[string]bool) {
    if mod in visited {
        return
    }
    visited[mod] = true
    for dep in g.module_imports[mod] {
        g.order_module_inits(dep, module_init, mut visited)
    }
    if init_key := module_init[mod] {
        if idx := g.fn_index[init_key] {
            g.init_fns << idx
        }
    }
}

// module_path_for_file returns the full import path whose directory form is a
// suffix of the file's directory (longest match), or '' for main/local code.
fn (g &Gen) module_path_for_file(file string) string {
    if file.len == 0 {
        return ''
    }
    dir := os.dir(file)
    mut best := ''
    for p in g.import_paths {
        if p.len <= best.len {
            continue
        }
        df := p.replace('.', os.path_separator)
        if dir == df || dir.ends_with(os.path_separator + df) {
            best = p
        }
    }
    return best
}

// resolve_call_keys returns the candidate fn_index keys for a callee, in
// priority order. A bare ident inside an imported module resolves to the
// same-module function first (`mod.name`) and falls back to a main-module name;
// a `module.fn()` selector resolves to that module's qualified name, with any
// import alias mapped back to the real module.
fn (g &Gen) resolve_call_keys(callee &flat.Node, cur_mod string, cur_file string) []string {
    if callee.kind == .ident {
        if cur_mod != '' && cur_mod != 'main' {
            return ['${cur_mod}.${callee.value}', callee.value]
        }
        return [callee.value]
    }
    if callee.kind == .selector && callee.children_count > 0 {
        base := g.a.child_node(callee, 0)
        if base.kind == .ident {
            real := g.resolve_module_alias(cur_file, base.value)
            return ['${real}.${callee.value}']
        }
    }
    return []
}

// resolve_module_alias maps an import alias to its real module using the
// aliases declared in the call site's source file, or returns the name as-is.
fn (g &Gen) resolve_module_alias(cur_file string, name string) string {
    if aliases := g.file_aliases[cur_file] {
        if real := aliases[name] {
            return real
        }
    }
    return name
}

// ---- print intrinsics ----

fn (mut g Gen) gen_print_call(node flat.Node, name string) {
    fd := if name.starts_with('e') { 2 } else { 1 }
    newline := name.ends_with('ln')
    if node.children_count < 2 {
        if newline {
            g.emit_write_const(nl_ptr, 1, fd)
        }
        return
    }
    arg_id := g.a.child(&node, 1)
    arg := g.a.nodes[int(arg_id)]
    if arg.kind == .string_literal {
        // arg.value is already unescaped by the parser (strip_quotes ->
        // unescape_string); use the bytes as-is, no second escape pass.
        bytes := arg.value.bytes()
        off := g.intern_data(bytes)
        g.emit_write_const(off, bytes.len, fd)
        if newline {
            g.emit_write_const(nl_ptr, 1, fd)
        }
        return
    }
    if arg.kind == .call {
        inner := g.a.child_node(&arg, 0)
        if inner.kind == .ident && arg.children_count >= 2 {
            if inner.value in signed_int_format_fns {
                g.emit_print_int(g.a.child(&arg, 1), fd, newline, true)
                return
            }
            if inner.value in unsigned_int_format_fns {
                g.emit_print_int(g.a.child(&arg, 1), fd, newline, false)
                return
            }
            if inner.value in bool_format_fns {
                g.gen_print_bool(g.a.child(&arg, 1), fd, newline)
                return
            }
        }
    }
    // integer expression passed directly (e.g. print(x))
    w := g.expr_wtype(arg_id, '')
    if w in [WType.i32, WType.i64] {
        g.emit_print_int(arg_id, fd, newline, !g.is_unsigned(arg_id))
        return
    }
    g.warn('unsupported ${name} argument: ${arg.kind}')
}

// gen_print_bool prints "true"/"false" based on the i32 truth value of arg.
fn (mut g Gen) gen_print_bool(arg_id flat.NodeId, fd int, newline bool) {
    true_off := g.intern_data('true'.bytes())
    false_off := g.intern_data('false'.bytes())
    g.gen_expr_as_bool(arg_id)
    g.cur.if_void()
    g.frames << Frame{
        tag: .plain
    }
    g.emit_write_const(true_off, 4, fd)
    g.cur.else_()
    g.emit_write_const(false_off, 5, fd)
    g.cur.end()
    g.frames.pop()
    if newline {
        g.emit_write_const(nl_ptr, 1, fd)
    }
}

// emit_print_int evaluates an integer expression and prints it via the runtime
// helper, choosing signed or unsigned decimal conversion.
fn (mut g Gen) emit_print_int(int_arg_id flat.NodeId, fd int, newline bool, signed bool) {
    w := g.gen_expr(int_arg_id)
    // Widen to i64 using the formatter's signedness (an unsigned formatter must
    // zero-extend, e.g. `1 + u64(x)` or a u32 result with the high bit set).
    g.coerce(w, .i64, signed)
    g.cur.i32_const(fd)
    g.cur.i32_const(if newline { 1 } else { 0 })
    g.cur.i32_const(if signed { 1 } else { 0 })
    g.cur.call(g.print_int_idx)
}

fn (mut g Gen) emit_write_const(ptr int, len int, fd int) {
    g.cur.i32_const(ptr)
    g.cur.i32_const(len)
    g.cur.i32_const(fd)
    g.cur.call(g.write_idx)
}

// emit_write_helper builds `__v_write(ptr, len, fd)` -> calls WASI fd_write.
fn (mut g Gen) emit_write_helper(fd_write_idx int) {
    mut c := Code{}
    // iov[0] = ptr  (mem @ iov_ptr)
    c.i32_const(iov_ptr)
    c.local_get(0)
    c.i32_store(0)
    // iov[1] = len  (mem @ iov_ptr+4)
    c.i32_const(iov_ptr)
    c.local_get(1)
    c.i32_store(4)
    // fd_write(fd, iov_ptr, 1, nwritten_ptr)
    c.local_get(2)
    c.i32_const(iov_ptr)
    c.i32_const(1)
    c.i32_const(nwritten_ptr)
    c.call(fd_write_idx)
    c.drop()
    c.end()
    ti := g.mod.add_type([valtype_i32, valtype_i32, valtype_i32], [])
    g.mod.add_func(ti, [], c.bytes)
}

// emit_print_int_helper builds `__v_print_int(val: i64, fd: i32, nl: i32,
// signed: i32)`. The digit loop uses unsigned div/rem, so passing signed=0
// prints the full u64 range; signed=1 adds two's-complement sign handling.
fn (mut g Gen) emit_print_int_helper() {
    // params: val(0,i64) fd(1,i32) nl(2,i32) signed(3,i32)
    // locals: p(4,i32) v(5,i64) neg(6,i32) digit(7,i64)
    signed := 3
    p := 4
    v := 5
    neg := 6
    digit := 7
    mut c := Code{}
    // neg = signed && val < 0
    c.local_get(0)
    c.i64_const(0)
    c.raw(0x53) // i64.lt_s
    c.local_get(signed)
    c.raw(0x71) // i32.and
    c.local_set(neg)
    // v = val
    c.local_get(0)
    c.local_set(v)
    // if neg { v = 0 - v }
    c.local_get(neg)
    c.if_void()
    c.i64_const(0)
    c.local_get(v)
    c.raw(0x7d) // i64.sub
    c.local_set(v)
    c.end()
    // p = buf_end
    c.i32_const(buf_end)
    c.local_set(p)
    // do { ... } while v != 0
    c.loop_void()
    c.local_get(p)
    c.i32_const(1)
    c.raw(0x6b) // i32.sub
    c.local_set(p)
    // digit = v % 10
    c.local_get(v)
    c.i64_const(10)
    c.raw(0x82) // i64.rem_u
    c.local_set(digit)
    // mem8[p] = '0' + digit
    c.local_get(p)
    c.local_get(digit)
    c.raw(0xa7) // i32.wrap_i64
    c.i32_const(48)
    c.raw(0x6a) // i32.add
    c.i32_store8(0)
    // v = v / 10
    c.local_get(v)
    c.i64_const(10)
    c.raw(0x80) // i64.div_u
    c.local_set(v)
    // continue if v != 0
    c.local_get(v)
    c.i64_const(0)
    c.raw(0x52) // i64.ne
    c.br_if(0)
    c.end() // loop
    // if neg { p--; mem8[p]='-' }
    c.local_get(neg)
    c.if_void()
    c.local_get(p)
    c.i32_const(1)
    c.raw(0x6b)
    c.local_set(p)
    c.local_get(p)
    c.i32_const(45) // '-'
    c.i32_store8(0)
    c.end()
    // __v_write(p, buf_end - p, fd)
    c.local_get(p)
    c.i32_const(buf_end)
    c.local_get(p)
    c.raw(0x6b) // i32.sub
    c.local_get(1) // fd
    c.call(g.write_idx)
    // if nl { __v_write(nl_ptr, 1, fd) }
    c.local_get(2)
    c.if_void()
    c.i32_const(nl_ptr)
    c.i32_const(1)
    c.local_get(1)
    c.call(g.write_idx)
    c.end()
    c.end() // function
    locals := [valtype_i32, valtype_i64, valtype_i32, valtype_i64]
    ti := g.mod.add_type([valtype_i64, valtype_i32, valtype_i32, valtype_i32], [])
    g.mod.add_func(ti, locals, c.bytes)
}

fn (mut g Gen) intern_data(bytes []u8) int {
    key := bytes.bytestr()
    if key in g.data_off {
        return g.data_off[key]
    }
    off := data_base + g.data_pool.len
    g.data_pool << bytes
    g.data_off[key] = off
    return off
}

// ---- type helpers ----

fn (mut g Gen) expr_wtype(id flat.NodeId, fallback_typ string) WType {
    if int(id) >= 0 {
        node := g.a.nodes[int(id)]
        // Locals are authoritative: our own table is more reliable than the
        // shared checker scope, which the backend does not repopulate.
        if node.kind == .ident && node.value in g.var_wtype {
            return g.var_wtype[node.value]
        }
        if node.kind == .ident {
            gkey := g.global_key(node.value)
            if gkey != '' {
                return g.global_wtype[gkey]
            }
        }
        if node.kind == .paren && node.children_count > 0 {
            return g.expr_wtype(g.a.child(&node, 0), fallback_typ)
        }
        if node.kind == .cast_expr && node.value.len > 0 {
            if w := prim_wtype(g.tc.parse_type(node.value)) {
                return w
            }
        }
        if node.kind == .infix && node.children_count >= 2 {
            if node.op in [.eq, .ne, .lt, .gt, .le, .ge, .logical_and, .logical_or] {
                return .i32
            }
            if node.op in [.left_shift, .right_shift, .right_shift_unsigned] {
                // Shift result width follows the lhs, not the (possibly wider) count.
                return g.expr_wtype(g.a.child(&node, 0), '')
            }
            return combine_wtype(g.expr_wtype(g.a.child(&node, 0), ''), g.expr_wtype(g.a.child(&node,
                1), ''))
        }
        if node.kind == .prefix && node.children_count >= 1 {
            if node.op == .not {
                return .i32
            }
            return g.expr_wtype(g.a.child(&node, 0), fallback_typ)
        }
    }
    t := g.tc.resolve_type(id)
    if w := prim_wtype(t) {
        if t !is types.Void {
            return w
        }
    }
    if fallback_typ.len > 0 && fallback_typ != 'void' {
        if w := prim_wtype(g.tc.parse_type(fallback_typ)) {
            return w
        }
    }
    return .i32
}

fn (mut g Gen) operand_wtype(lhs_id flat.NodeId, rhs_id flat.NodeId) WType {
    return combine_wtype(g.expr_wtype(lhs_id, ''), g.expr_wtype(rhs_id, ''))
}

// combine_wtype picks the widest of two value types (float beats int, 64 beats
// 32), which is the shared operand/result width for a binary operation.
fn combine_wtype(a WType, b WType) WType {
    if a == .f64 || b == .f64 {
        return .f64
    }
    if a == .f32 || b == .f32 {
        return .f32
    }
    if a == .i64 || b == .i64 {
        return .i64
    }
    return .i32
}

fn (mut g Gen) is_unsigned(id flat.NodeId) bool {
    if int(id) >= 0 {
        node := g.a.nodes[int(id)]
        if node.kind == .ident && node.value in g.var_unsigned {
            return g.var_unsigned[node.value]
        }
        if node.kind == .ident {
            gkey := g.global_key(node.value)
            if gkey != '' {
                return g.global_unsigned[gkey]
            }
        }
        if node.kind == .paren && node.children_count > 0 {
            return g.is_unsigned(g.a.child(&node, 0))
        }
        if node.kind == .cast_expr && node.value.len > 0 {
            return type_is_unsigned(g.tc.parse_type(node.value))
        }
    }
    return type_is_unsigned(g.tc.resolve_type(id))
}

// decl_is_unsigned resolves the signedness of a declared variable's initializer.
fn (mut g Gen) decl_is_unsigned(rhs_id flat.NodeId, fallback_typ string) bool {
    if g.is_unsigned(rhs_id) {
        return true
    }
    if fallback_typ.len > 0 {
        return type_is_unsigned(g.tc.parse_type(fallback_typ))
    }
    return false
}

fn type_is_unsigned(t_ types.Type) bool {
    t := unalias(t_)
    if t is types.Primitive {
        return t.props.has(.unsigned)
    }
    return t is types.USize
}

// narrow_width returns 8 or 16 for sub-32-bit integer types (which the backend
// stores in an i32 and must mask/sign-extend), or 32 otherwise.
fn narrow_width(t_ types.Type) int {
    t := unalias(t_)
    if t is types.Primitive && t.props.has(.integer) {
        if t.size == 8 {
            return 8
        }
        if t.size == 16 {
            return 16
        }
    }
    return 32
}

fn (mut g Gen) is_signed(id flat.NodeId) bool {
    return !g.is_unsigned(id)
}

fn (mut g Gen) coerce(from WType, to WType, signed bool) {
    if from == to || from == .void || to == .void {
        return
    }
    match to {
        .i64 {
            if from == .i32 {
                g.cur.raw(if signed { u8(0xac) } else { u8(0xad) }) // i64.extend_i32_s/u
            } else if from == .f32 || from == .f64 {
                g.emit_float_to_int(from, .i64, signed)
            }
        }
        .i32 {
            if from == .i64 {
                g.cur.raw(0xa7) // i32.wrap_i64
            } else if from == .f32 || from == .f64 {
                g.emit_float_to_int(from, .i32, signed)
            }
        }
        .f64 {
            match from {
                .i32 { g.cur.raw(if signed { u8(0xb7) } else { u8(0xb8) }) }
                .i64 { g.cur.raw(if signed { u8(0xb9) } else { u8(0xba) }) }
                .f32 { g.cur.raw(0xbb) } // f64.promote_f32
                else {}
            }
        }
        .f32 {
            match from {
                .i32 { g.cur.raw(if signed { u8(0xb2) } else { u8(0xb3) }) }
                .i64 { g.cur.raw(if signed { u8(0xb4) } else { u8(0xb5) }) }
                .f64 { g.cur.raw(0xb6) } // f32.demote_f64
                else {}
            }
        }
        else {}
    }
}

fn (mut g Gen) emit_arith(op flat.Op, w WType, signed bool) {
    if op in [.left_shift, .right_shift, .right_shift_unsigned] {
        g.emit_shift_op(op, w, w, signed)
        return
    }
    g.cur.raw(arith_op(op, w, signed))
}

// emit_shift_with_count generates the (already-on-stack value's) shift count at
// its natural width and emits the shift. The result keeps the value's width
// while V permits a wider shift count, so value and count widths may differ.
fn (mut g Gen) emit_shift_with_count(op flat.Op, value_w WType, rhs_id flat.NodeId, signed bool) {
    count_w := if g.expr_wtype(rhs_id, '') == .i64 { WType.i64 } else { WType.i32 }
    g.gen_expr_as(rhs_id, count_w)
    g.emit_shift_op(op, value_w, count_w, signed)
}

// emit_shift_op emits a shift with V's over-width semantics: WASM masks the
// count modulo the value width, but V yields 0 once the (full-width) count
// reaches the value width. Stack on entry: [value(value_w), count(count_w)];
// on exit: [result(value_w)].
fn (mut g Gen) emit_shift_op(op flat.Op, value_w WType, count_w WType, signed bool) {
    tmp := g.alloc_temp(count_w)
    g.cur.local_tee(tmp) // keep the original count, also store it
    // The WASM shift opcode needs the count at the value width.
    if count_w == .i64 && value_w == .i32 {
        g.cur.raw(0xa7) // i32.wrap_i64
    } else if count_w == .i32 && value_w == .i64 {
        g.cur.raw(0xad) // i64.extend_i32_u
    }
    g.cur.raw(arith_op(op, value_w, signed)) // value << (count mod value width)
    // result = (count < value_width) ? shifted : 0, comparing the full count.
    // V promotes narrow types to int for shifts, so the threshold is the
    // computation (WASM) width, not the declared 8/16 (matches v1: i8(-1) >> 8
    // stays -1, while u32 << 32 and u64 << 64 become 0).
    width := if value_w == .i64 { 64 } else { 32 }
    if value_w == .i64 {
        g.cur.i64_const(0)
    } else {
        g.cur.i32_const(0)
    }
    g.cur.local_get(tmp)
    if count_w == .i64 {
        g.cur.i64_const(width)
        g.cur.raw(0x54) // i64.lt_u
    } else {
        g.cur.i32_const(width)
        g.cur.raw(0x49) // i32.lt_u
    }
    g.cur.raw(0x1b) // select
}

// emit_float_to_int truncates a float to an integer with V's saturating cast
// semantics (NaN -> 0, out-of-range saturates to the target min/max), using the
// target type's signedness rather than the source's.
fn (mut g Gen) emit_float_to_int(from WType, to WType, signed bool) {
    g.cur.raw(0xfc) // saturating-truncation prefix
    op2 := if to == .i64 {
        if from == .f32 {
            if signed { u8(0x04) } else { u8(0x05) }
        } else {
            if signed { u8(0x06) } else { u8(0x07) }
        }
    } else {
        if from == .f32 {
            if signed { u8(0x00) } else { u8(0x01) }
        } else {
            if signed { u8(0x02) } else { u8(0x03) }
        }
    }
    g.cur.raw(op2)
}

// emit_narrow masks (unsigned) or sign-extends (signed) the i32 on the stack to
// a sub-32-bit width; a no-op for 32/64-bit values.
fn (mut g Gen) emit_narrow(width int, unsigned bool) {
    match width {
        8 {
            if unsigned {
                g.cur.i32_const(0xff)
                g.cur.raw(0x71) // i32.and
            } else {
                g.cur.raw(0xc0) // i32.extend8_s
            }
        }
        16 {
            if unsigned {
                g.cur.i32_const(0xffff)
                g.cur.raw(0x71) // i32.and
            } else {
                g.cur.raw(0xc1) // i32.extend16_s
            }
        }
        else {}
    }
}

fn (mut g Gen) warn(msg string) {
    g.warnings << msg
}

// ---- free helpers ----

fn wt_valtype(w WType) u8 {
    return match w {
        .i32, .void { valtype_i32 }
        .i64 { valtype_i64 }
        .f32 { valtype_f32 }
        .f64 { valtype_f64 }
    }
}

// qualified_fn_key keys fn_index/fn_ret/fn_params: a bare name for the main
// module, `module.name` for imported modules (matching call-site selectors).
fn qualified_fn_key(mod string, name string) string {
    if mod == '' || mod == 'main' {
        return name
    }
    return '${mod}.${name}'
}

// export_fn_name is the wasm export name for a function (`.` is replaced so the
// name is convenient to reference from a host like JS).
fn export_fn_name(mod string, name string) string {
    if mod == '' || mod == 'main' {
        return name
    }
    return '${mod.replace('.', '__')}__${name}'
}

// unalias resolves a (possibly chained) numeric type alias to its base type so
// scalar aliases like `type Byte = u8` classify as their underlying type.
fn unalias(t types.Type) types.Type {
    mut cur := t
    for {
        if cur is types.Alias {
            cur = cur.base_type
        } else {
            break
        }
    }
    return cur
}

// prim_wtype maps a primitive/numeric/bool V type to a WASM value type, or none
// for aggregate/reference types the backend cannot yet represent inline.
fn prim_wtype(t_ types.Type) ?WType {
    t := unalias(t_)
    if t is types.Primitive {
        if t.props.has(.float) {
            return if t.size == 32 { WType.f32 } else { WType.f64 }
        }
        if t.props.has(.integer) {
            return if t.size == 64 { WType.i64 } else { WType.i32 }
        }
        if t.props.has(.boolean) {
            return WType.i32
        }
        return WType.i32
    }
    if t is types.Char || t is types.Rune || t is types.ISize || t is types.USize {
        return WType.i32
    }
    return none
}

const signed_int_format_fns = ['strconv__format_int', 'int_str', 'i64_str', 'i8_str', 'i16_str',
    'i32_str', 'isize_str']

const unsigned_int_format_fns = ['strconv__format_uint', 'u8_str', 'u16_str', 'u32_str', 'u64_str',
    'usize_str']

const bool_format_fns = ['bool.str', 'bool__str', 'bool_str']

fn compound_to_op(op flat.Op) flat.Op {
    return match op {
        .plus_assign { flat.Op.plus }
        .minus_assign { flat.Op.minus }
        .mul_assign { flat.Op.mul }
        .div_assign { flat.Op.div }
        .mod_assign { flat.Op.mod }
        .amp_assign { flat.Op.amp }
        .pipe_assign { flat.Op.pipe }
        .xor_assign { flat.Op.xor }
        .left_shift_assign { flat.Op.left_shift }
        .right_shift_assign { flat.Op.right_shift }
        .right_shift_unsigned_assign { flat.Op.right_shift_unsigned }
        else { flat.Op.plus }
    }
}

fn arith_op(op flat.Op, w WType, signed bool) u8 {
    match w {
        .i64 {
            return match op {
                .plus {
                    0x7c
                }
                .minus {
                    0x7d
                }
                .mul {
                    0x7e
                }
                .div {
                    if signed {
                        u8(0x7f)
                    } else {
                        u8(0x80)
                    }
                }
                .mod {
                    if signed {
                        u8(0x81)
                    } else {
                        u8(0x82)
                    }
                }
                .amp {
                    0x83
                }
                .pipe {
                    0x84
                }
                .xor {
                    0x85
                }
                .left_shift {
                    0x86
                }
                .right_shift {
                    0x87
                }
                .right_shift_unsigned {
                    0x88
                }
                else {
                    0x7c
                }
            }
        }
        .f64 {
            return match op {
                .plus { 0xa0 }
                .minus { 0xa1 }
                .mul { 0xa2 }
                .div { 0xa3 }
                else { 0xa0 }
            }
        }
        .f32 {
            return match op {
                .plus { 0x92 }
                .minus { 0x93 }
                .mul { 0x94 }
                .div { 0x95 }
                else { 0x92 }
            }
        }
        else {
            return match op {
                .plus {
                    0x6a
                }
                .minus {
                    0x6b
                }
                .mul {
                    0x6c
                }
                .div {
                    if signed {
                        u8(0x6d)
                    } else {
                        u8(0x6e)
                    }
                }
                .mod {
                    if signed {
                        u8(0x6f)
                    } else {
                        u8(0x70)
                    }
                }
                .amp {
                    0x71
                }
                .pipe {
                    0x72
                }
                .xor {
                    0x73
                }
                .left_shift {
                    0x74
                }
                .right_shift {
                    if signed {
                        u8(0x75)
                    } else {
                        u8(0x76)
                    }
                }
                .right_shift_unsigned {
                    0x76
                }
                else {
                    0x6a
                }
            }
        }
    }
}

fn cmp_op(op flat.Op, w WType, signed bool) u8 {
    match w {
        .i64 {
            return match op {
                .eq {
                    0x51
                }
                .ne {
                    0x52
                }
                .lt {
                    if signed {
                        u8(0x53)
                    } else {
                        u8(0x54)
                    }
                }
                .gt {
                    if signed {
                        u8(0x55)
                    } else {
                        u8(0x56)
                    }
                }
                .le {
                    if signed {
                        u8(0x57)
                    } else {
                        u8(0x58)
                    }
                }
                .ge {
                    if signed {
                        u8(0x59)
                    } else {
                        u8(0x5a)
                    }
                }
                else {
                    0x51
                }
            }
        }
        .f64 {
            return match op {
                .eq { 0x61 }
                .ne { 0x62 }
                .lt { 0x63 }
                .gt { 0x64 }
                .le { 0x65 }
                .ge { 0x66 }
                else { 0x61 }
            }
        }
        .f32 {
            return match op {
                .eq { 0x5b }
                .ne { 0x5c }
                .lt { 0x5d }
                .gt { 0x5e }
                .le { 0x5f }
                .ge { 0x60 }
                else { 0x5b }
            }
        }
        else {
            return match op {
                .eq {
                    0x46
                }
                .ne {
                    0x47
                }
                .lt {
                    if signed {
                        u8(0x48)
                    } else {
                        u8(0x49)
                    }
                }
                .gt {
                    if signed {
                        u8(0x4a)
                    } else {
                        u8(0x4b)
                    }
                }
                .le {
                    if signed {
                        u8(0x4c)
                    } else {
                        u8(0x4d)
                    }
                }
                .ge {
                    if signed {
                        u8(0x4e)
                    } else {
                        u8(0x4f)
                    }
                }
                else {
                    0x46
                }
            }
        }
    }
}

fn parse_int_literal(s_ string) i64 {
    mut s := s_.replace('_', '')
    mut neg := false
    if s.starts_with('-') {
        neg = true
        s = s[1..]
    }
    mut val := i64(0)
    if s.starts_with('0x') || s.starts_with('0X') {
        val = i64(s[2..].parse_uint(16, 64) or { 0 })
    } else if s.starts_with('0o') || s.starts_with('0O') {
        val = i64(s[2..].parse_uint(8, 64) or { 0 })
    } else if s.starts_with('0b') || s.starts_with('0B') {
        val = i64(s[2..].parse_uint(2, 64) or { 0 })
    } else {
        // parse_uint preserves the full u64 bit pattern; string.i64() would
        // saturate values above i64 max (e.g. u64(18446744073709551615)).
        val = i64(s.parse_uint(10, 64) or { 0 })
    }
    return if neg { -val } else { val }
}

// char_literal_value decodes a char-literal node value to its code point.
fn char_literal_value(s string) i64 {
    if s.len == 0 {
        return 0
    }
    if s[0] == `\\` && s.len >= 2 {
        return match s[1] {
            `n` { i64(10) }
            `t` { i64(9) }
            `r` { i64(13) }
            `\\` { i64(92) }
            `'` { i64(39) }
            `"` { i64(34) }
            `0` { i64(0) }
            `a` { i64(7) }
            `b` { i64(8) }
            `f` { i64(12) }
            `v` { i64(11) }
            else { i64(s[1]) }
        }
    }
    if s.len == 1 {
        return i64(s[0])
    }
    // multi-byte UTF-8 rune: use the first code point
    runes := s.runes()
    return if runes.len > 0 { i64(runes[0]) } else { i64(s[0]) }
}