// Copyright (c) 2023 l-m.dev. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module wasm

import v.ast
import v.pref
import v.util
import v.token
import v.errors
import v.gen.wasm.serialise
import wasm
import os

@[heap; minify]
pub struct Gen {
    out_name string
    pref     &pref.Preferences = unsafe { nil } // Preferences shared from V struct
    files    []&ast.File
mut:
    file_path string // current ast.File path
    warnings  []errors.Warning
    errors    []errors.Error
    table     &ast.Table = unsafe { nil }
    enum_vals map[string]Enum

    mod                    wasm.Module
    pool                   serialise.Pool
    func                   wasm.Function
    local_vars             []Var
    global_vars            map[string]Global
    ret_rvars              []Var
    ret                    ast.Type
    ret_types              []ast.Type
    ret_br                 wasm.LabelIndex
    bp_idx                 wasm.LocalIndex = -1 // Base pointer temporary's index for function, if needed (-1 for none)
    sp_global              ?wasm.GlobalIndex
    heap_base              ?wasm.GlobalIndex
    fn_local_idx_end       int
    fn_name                string
    stack_frame            int // Size of the current stack frame, if needed
    is_leaf_function       bool = true
    loop_breakpoint_stack  []LoopBreakpoint
    stack_top              int // position in linear memory
    data_base              int // position in linear memory
    needs_address          bool
    defer_vars             []Var
    is_direct_array_access bool // inside a `[direct_array_access]` function
    // function values: fn name -> slot in the `__indirect_function_table`.
    // Single owner of the indirect-call table population (reused by later phases).
    fn_value_indices   map[string]int
    pending_anon_fns   []ast.FnDecl    // non-capturing anon fns to compile after toplevel stmts
    compiled_anon_fns  map[string]bool // dedup for pending_anon_fns
    uses_call_indirect bool            // a `call_indirect` was emitted, so the table must exist
}

// fn_table_index returns the slot of `name` in the indirect function table,
// registering it (and growing the table) on first use.
pub fn (mut g Gen) fn_table_index(name string) int {
    if idx := g.fn_value_indices[name] {
        return idx
    }
    // Slot 0 is reserved as the null/trap slot, so a real function value never
    // collides with `unsafe { nil }` (which also lowers to `i32.const 0`). Real
    // functions therefore start at index 1.
    idx := g.fn_value_indices.len + 1
    g.fn_value_indices[name] = idx
    return idx
}

struct Global {
mut:
    init ?ast.Expr
    v    Var
}

pub struct LoopBreakpoint {
    c_continue wasm.LabelIndex
    c_break    wasm.LabelIndex
    name       string
}

@[noreturn]
pub fn (mut g Gen) v_error(s string, pos token.Pos) {
    util.show_compiler_message('error:', pos: pos, file_path: g.file_path, message: s)
    exit(1)
    /*
    if g.pref.output_mode == .stdout {
        util.show_compiler_message('error:', pos: pos, file_path: g.file_path, message: s)
        exit(1)
    } else {
        g.errors << errors.Error{
            file_path: g.file_path
            pos: pos
            reporter: .gen
            message: s
        }
    }
    */
}

pub fn (mut g Gen) warning(s string, pos token.Pos) {
    if g.pref.output_mode == .stdout {
        util.show_compiler_message('warning:', pos: pos, file_path: g.file_path, message: s)
    } else {
        g.warnings << errors.Warning{
            file_path: g.file_path
            pos:       pos
            reporter:  .gen
            message:   s
        }
    }
}

@[noreturn]
pub fn (mut g Gen) w_error(s string) {
    if g.pref.is_verbose {
        print_backtrace()
    }
    util.verror('wasm error', s)
}

pub fn (g &Gen) unpack_type(typ ast.Type) []ast.Type {
    ts := g.table.sym(typ)
    return match ts.info {
        ast.MultiReturn {
            ts.info.types
        }
        else {
            [typ]
        }
    }
}

pub fn (g &Gen) is_param_type(typ ast.Type) bool {
    return !typ.is_ptr() && !g.is_pure_type(typ)
}

pub fn (mut g Gen) dbg_type_name(name string, typ ast.Type) string {
    return '${name}<${`&`.repeat(typ.nr_muls())}${*g.table.sym(typ)}>'
}

pub fn unpack_literal_int(typ ast.Type) ast.Type {
    return if typ == ast.int_literal_type { ast.i64_type } else { typ }
}

pub fn (g &Gen) get_ns_plus_name(default_name string, attrs []ast.Attr) (string, string) {
    mut name := default_name
    mut namespace := 'env'

    if cattr := attrs.find_first('wasm_import_namespace') {
        namespace = cattr.arg
    }
    if cattr := attrs.find_first('wasm_import_name') {
        name = cattr.arg
    }

    return namespace, name
}

pub fn (mut g Gen) fn_external_import(node ast.FnDecl) {
    if !node.no_body || node.is_method {
        g.v_error('interop functions cannot have bodies', node.body_pos)
    }
    if node.language == .js && g.pref.os == .wasi {
        g.v_error('javascript interop functions are not allowed in a `wasi` build', node.pos)
    }
    if node.return_type.has_option_or_result() {
        g.v_error('interop functions must not return option or result', node.pos)
    }

    mut paraml := []wasm.ValType{cap: node.params.len}
    mut retl := []wasm.ValType{cap: 1}
    for arg in node.params {
        if !g.is_pure_type(arg.typ) {
            g.v_error('interop functions do not support complex arguments', arg.type_pos)
        }
        paraml << g.get_wasm_type(arg.typ)
    }

    is_ret := node.return_type != ast.void_type

    if is_ret && !g.is_pure_type(node.return_type) {
        g.v_error('interop functions do not support complex returns', node.return_type_pos)
    }
    if is_ret {
        retl << g.get_wasm_type(node.return_type)
    }

    namespace, name := g.get_ns_plus_name(node.short_name, node.attrs)
    g.mod.new_function_import(namespace, name, paraml, retl)
}

pub fn (mut g Gen) fn_decl(node ast.FnDecl) {
    if node.language in [.js, .wasm] {
        g.fn_external_import(node)
        return
    }

    if node.attrs.contains('flag_enum_fn') {
        // TODO: remove, when support for fn results is done
        return
    }

    name := if node.is_method {
        '${g.table.get_type_name(node.receiver.typ)}.${node.name}'
    } else {
        node.name
    }

    util.timing_start('${@METHOD}: ${name}')
    defer {
        util.timing_measure('${@METHOD}: ${name}')
    }

    if node.no_body {
        return
    }
    if g.pref.is_verbose {
        // println(term.green('\n${name}:'))
    }
    if node.is_deprecated {
        g.warning('fn_decl: ${name} is deprecated', node.pos)
    }

    mut paramdbg := []?string{cap: node.params.len}
    mut paraml := []wasm.ValType{cap: node.params.len}
    mut retl := []wasm.ValType{cap: 1}

    // fn ()!       | fn () &IError
    // fn () ?(...) | fn () (..., bool)
    // fn () !(...) | fn () (..., &IError)
    //
    // fn (...) struct      | fn (_ &struct, ...)
    // fn (...) !struct     | fn (_ &struct, ...) &IError
    // fn (...) (...struct) | fn (...&struct, ...)

    g.ret_rvars = []Var{}
    rt := node.return_type
    rts := g.table.sym(rt)
    g.ret = rt
    match rts.info {
        ast.MultiReturn {
            for t in rts.info.types {
                wtyp := g.get_wasm_type(t)
                if g.is_param_type(t) {
                    paramdbg << g.dbg_type_name('__rval(${g.ret_rvars.len})', t)
                    paraml << wtyp
                    g.ret_rvars << Var{
                        typ:        t
                        idx:        g.ret_rvars.len
                        is_address: true
                    }
                } else {
                    retl << wtyp
                }
                g.ret_types << t
            }
            if rt.has_flag(.option) {
                g.v_error('option types are not implemented', node.return_type_pos)
                retl << .i32_t // bool
            }
        }
        else {
            if rt.idx() != ast.void_type_idx {
                // A scalar `?T`/`!T` return reaches here (it is not a MultiReturn),
                // so the option/result guards below — which only run inside the
                // MultiReturn arm or after the match — are dead for it. Guard before
                // `get_wasm_type`, which would otherwise abort with an internal
                // "unreachable type" ICE on the option/result-wrapped type.
                if rt.has_flag(.option) {
                    g.v_error('option types are not implemented', node.return_type_pos)
                }
                if rt.has_flag(.result) {
                    g.v_error('result types are not implemented', node.return_type_pos)
                }
                wtyp := g.get_wasm_type(rt)
                if g.is_param_type(rt) {
                    paramdbg << g.dbg_type_name('__rval(0)', rt)
                    paraml << wtyp
                    g.ret_rvars << Var{
                        typ:        rt
                        is_address: true
                    }
                } else {
                    retl << wtyp
                }
                g.ret_types << rt
            } else if rt.has_flag(.option) {
                g.v_error('returning a void option is forbidden', node.return_type_pos)
            }
        }
    }

    if rt.has_flag(.result) {
        g.v_error('result types are not implemented', node.return_type_pos)
        retl << .i32_t // &IError
    }

    for p in node.params {
        typ := g.get_wasm_type_int_literal(p.typ)
        ntyp := unpack_literal_int(p.typ)
        g.local_vars << Var{
            name:       p.name
            typ:        ntyp
            idx:        g.local_vars.len + g.ret_rvars.len
            is_address: !g.is_pure_type(p.typ)
        }
        paramdbg << g.dbg_type_name(p.name, p.typ)
        paraml << typ
    }

    // bottom scope

    g.is_direct_array_access = node.is_direct_arr || g.pref.no_bounds_checking
    g.fn_local_idx_end = (g.local_vars.len + g.ret_rvars.len)
    g.fn_name = name

    mut should_export := g.pref.os in [.browser, .wasi] && node.is_pub && node.mod == 'main'

    g.func = g.mod.new_debug_function(name, wasm.FuncType{paraml, retl, none}, paramdbg)
    func_start := g.func.patch_pos()
    if node.stmts.len > 0 {
        g.ret_br = g.func.c_block([], retl)
        {
            g.expr_stmts(node.stmts, ast.void_type)
        }
        {
            for idx, defer_stmt in node.defer_stmts {
                g.get(g.defer_vars[idx])
                lbl := g.func.c_if([], [])
                {
                    g.expr_stmts(defer_stmt.stmts, ast.void_type)
                }
                g.func.c_end(lbl)
            }
        }
        g.func.c_end(g.ret_br)
        g.bare_function_frame(func_start)
    }
    if cattr := node.attrs.find_first('export') {
        g.func.export_name(cattr.arg)
        should_export = true
    }
    g.mod.commit(g.func, should_export)
    g.bare_function_end()

    // printfn is not implemented!
}

pub fn (mut g Gen) bare_function_frame(func_start wasm.PatchPos) {
    // Setup stack frame.
    // If the function does not call other functions,
    // a leaf function, the omission of setting the
    // stack pointer is perfectly acceptable.
    //
    if g.stack_frame != 0 {
        prologue := g.func.patch_pos()
        {
            g.func.global_get(g.sp())
            g.func.i32_const(i32(g.stack_frame))
            g.func.sub(.i32_t)
            if !g.is_leaf_function {
                g.func.local_tee(g.bp())
                g.func.global_set(g.sp())
            } else {
                g.func.local_set(g.bp())
            }
        }
        g.func.patch(func_start, prologue)
        if !g.is_leaf_function {
            g.func.global_get(g.sp())
            g.func.i32_const(i32(g.stack_frame))
            g.func.add(.i32_t)
            g.func.global_set(g.sp())
        }
    }
}

pub fn (mut g Gen) bare_function_end() {
    g.local_vars.clear()
    g.ret_rvars.clear()
    g.ret_types.clear()
    g.defer_vars.clear()
    g.bp_idx = -1
    g.stack_frame = 0
    g.is_leaf_function = true
    g.is_direct_array_access = false
    assert g.loop_breakpoint_stack.len == 0
}

pub fn (mut g Gen) literalint(val i64, expected ast.Type) {
    match g.get_wasm_type(expected) {
        .i32_t { g.func.i32_const(i32(val)) }
        .i64_t { g.func.i64_const(val) }
        .f32_t { g.func.f32_const(f32(val)) }
        .f64_t { g.func.f64_const(f64(val)) }
        else { g.w_error('literalint: bad type `${expected}`') }
    }
}

pub fn (mut g Gen) literal(val string, expected ast.Type) {
    match g.get_wasm_type(expected) {
        .i32_t { g.func.i32_const(i32(val.int())) }
        .i64_t { g.func.i64_const(val.i64()) }
        .f32_t { g.func.f32_const(val.f32()) }
        .f64_t { g.func.f64_const(val.f64()) }
        else { g.w_error('literal: bad type `${expected}`') }
    }
}

pub fn (mut g Gen) cast(typ ast.Type, expected_type ast.Type) {
    wtyp := g.as_numtype(g.get_wasm_type_int_literal(typ))
    expected_wtype := g.as_numtype(g.get_wasm_type_int_literal(expected_type))

    g.func.cast(wtyp, typ.is_signed(), expected_wtype)
}

pub fn (mut g Gen) expr_with_cast(expr ast.Expr, got_type_raw ast.Type, expected_type ast.Type) {
    if expr is ast.IntegerLiteral {
        g.literal(expr.val, expected_type)
        return
    } else if expr is ast.FloatLiteral {
        g.literal(expr.val, expected_type)
        return
    }

    got_type := ast.mktyp(got_type_raw)
    got_wtype := g.as_numtype(g.get_wasm_type(got_type))
    expected_wtype := g.as_numtype(g.get_wasm_type(expected_type))

    g.expr(expr, got_type)
    g.func.cast(got_wtype, got_type.is_signed(), expected_wtype)
}

pub fn (mut g Gen) handle_ptr_arithmetic(typ ast.Type) {
    if typ.is_ptr() {
        size, _ := g.pool.type_size(typ)
        g.func.i32_const(i32(size))
        g.func.mul(.i32_t)
    }
}

fn (mut g Gen) handle_string_operation(op token.Kind) {
    left_tmp := g.func.new_local_named(.i32_t, '__tmp<string>.left')
    right_tmp := g.func.new_local_named(.i32_t, '__tmp<string>.right')
    g.func.local_set(right_tmp)
    g.func.local_set(left_tmp)

    match op {
        .plus {
            ret_var := g.new_local('', ast.string_type)
            g.ref(ret_var)
            g.func.local_get(left_tmp)
            g.func.local_get(right_tmp)
            g.func.call('string.+')
            g.get(ret_var)
        }
        .eq {
            g.func.local_get(left_tmp)
            g.func.local_get(right_tmp)
            g.func.call('string.==')
        }
        .ne {
            g.func.local_get(left_tmp)
            g.func.local_get(right_tmp)
            g.func.call('string.==')
            g.func.eqz(.i32_t)
        }
        .lt {
            g.func.local_get(left_tmp)
            g.func.local_get(right_tmp)
            g.func.call('string.<')
        }
        .gt {
            g.func.local_get(right_tmp)
            g.func.local_get(left_tmp)
            g.func.call('string.<')
        }
        .le {
            g.func.local_get(right_tmp)
            g.func.local_get(left_tmp)
            g.func.call('string.<')
            g.func.eqz(.i32_t)
        }
        .ge {
            g.func.local_get(left_tmp)
            g.func.local_get(right_tmp)
            g.func.call('string.<')
            g.func.eqz(.i32_t)
        }
        else {
            g.w_error('unsupported string operation: `${op}`')
        }
    }
}

pub fn (mut g Gen) string_inter_literal_expr(node ast.StringInterLiteral, expected ast.Type) {
    if node.exprs.len == 0 {
        g.expr(ast.StringLiteral{ val: node.vals[0], pos: node.pos }, expected)
        return
    }

    result_var := g.new_local('__str_inter', ast.string_type)

    g.set_with_expr(ast.StringLiteral{ val: node.vals[0], pos: node.pos }, result_var)

    for i, expr in node.exprs {
        mut expr_to_concat := expr
        typ := node.expr_types[i]

        if typ != ast.string_type {
            has_str, _, _ := g.table.sym(typ).str_method_info()
            if !has_str {
                g.v_error('cannot interpolate type without .str() method', node.fmt_poss[i])
            }

            expr_to_concat = ast.CallExpr{
                name:           'str'
                left:           expr
                left_type:      typ
                receiver_type:  typ
                return_type:    ast.string_type
                is_method:      true
                is_return_used: true
            }
        }

        // result = result + expr_as_string
        {
            g.get(result_var)
            g.expr(expr_to_concat, ast.string_type)
            g.handle_string_operation(.plus)
            g.set(result_var)
        }

        // Concat the next string segment (if not empty)
        if i + 1 < node.vals.len && node.vals[i + 1].len > 0 {
            g.get(result_var)
            g.expr(ast.StringLiteral{ val: node.vals[i + 1], pos: node.pos }, ast.string_type)
            g.handle_string_operation(.plus)
            g.set(result_var)
        }
    }

    g.get(result_var)
}

pub fn (mut g Gen) infix_expr(node ast.InfixExpr, expected ast.Type) {
    if node.op in [.logical_or, .and] {
        temp := g.func.new_local_named(.i32_t, '__tmp<bool>')
        {
            g.expr(node.left, ast.bool_type)
            g.func.local_set(temp)
        }
        g.func.local_get(temp)
        if node.op == .logical_or {
            g.func.eqz(.i32_t)
        }

        blk := g.func.c_if([], [.i32_t])
        {
            g.expr(node.right, ast.bool_type)
        }
        g.func.c_else(blk)
        {
            g.func.local_get(temp)
        }
        g.func.c_end(blk)
        return
    }

    {
        g.expr(node.left, node.left_type)
    }
    {
        g.expr_with_cast(node.right, node.right_type, node.left_type)
        if node.op in [.plus, .minus] && node.left_type.is_ptr() {
            g.handle_ptr_arithmetic(node.left_type.deref())
        }
    }
    g.infix_from_typ(node.left_type, node.op)

    res_typ := if node.op in [.eq, .ne, .gt, .lt, .ge, .le] { ast.bool_type } else { node.left_type }
    g.func.cast(g.as_numtype(g.get_wasm_type(res_typ)), res_typ.is_signed(),
        g.as_numtype(g.get_wasm_type(expected)))
}

pub fn (mut g Gen) prefix_expr(node ast.PrefixExpr, expected ast.Type) {
    match node.op {
        .minus {
            if node.right_type.is_pure_float() {
                g.expr(node.right, node.right_type)
                if node.right_type == ast.f32_type_idx {
                    g.func.neg(.f32_t)
                } else {
                    g.func.neg(.f64_t)
                }
            } else {
                // -val == 0 - val

                vt := g.get_wasm_type(node.right_type)

                g.literalint(0, node.right_type)
                g.expr(node.right, node.right_type)
                g.func.sub(g.as_numtype(vt))
            }
        }
        .not {
            g.expr(node.right, node.right_type)
            g.func.eqz(.i32_t) // !expr
        }
        .bit_not {
            // ~val == val ^ -1

            vt := g.get_wasm_type(node.right_type)

            g.expr(node.right, node.right_type)
            g.literalint(-1, node.right_type)
            g.func.b_xor(g.as_numtype(vt))
        }
        .amp {
            if v := g.get_var_from_expr(node.right) {
                if !v.is_address {
                    g.v_error("cannot take the address of a value that doesn't live on the stack",
                        node.pos)
                }
                g.ref(v)
            } else {
                g.needs_address = true
                {
                    g.expr(node.right, node.right_type)
                }
                g.needs_address = false
            }
        }
        .mul {
            g.expr(node.right, node.right_type)
            if g.is_pure_type(expected) && !g.needs_address {
                // in a RHS context, not lvalue
                g.load(expected, 0)
            }
        }
        else {
            // impl deref (.mul), and impl address of (.amp)
            g.w_error('`${node.op}val` prefix expression not implemented')
        }
    }
}

pub fn (mut g Gen) if_branch(ifexpr ast.IfExpr, expected ast.Type, unpacked_params []wasm.ValType, idx int,
    existing_rvars []Var) {
    curr := ifexpr.branches[idx]

    g.expr(curr.cond, ast.bool_type)
    blk := g.func.c_if([], unpacked_params)
    {
        g.rvar_expr_stmts(curr.stmts, expected, existing_rvars)
    }
    {
        if ifexpr.has_else && idx + 2 >= ifexpr.branches.len {
            g.func.c_else(blk)
            g.rvar_expr_stmts(ifexpr.branches[idx + 1].stmts, expected, existing_rvars)
        } else if !(idx + 1 >= ifexpr.branches.len) {
            g.func.c_else(blk)
            g.if_branch(ifexpr, expected, unpacked_params, idx + 1, existing_rvars)
        }
    }
    g.func.c_end(blk)
}

pub fn (mut g Gen) if_expr(ifexpr ast.IfExpr, expected ast.Type, existing_rvars []Var) {
    if ifexpr.is_comptime {
        g.comptime_if_expr(ifexpr, expected, existing_rvars)
        return
    }

    params := if expected == ast.void_type {
        []wasm.ValType{}
    } else if existing_rvars.len == 0 {
        g.unpack_type(expected).map(g.get_wasm_type(it))
    } else {
        g.unpack_type(expected).filter(!g.is_param_type(it)).map(g.get_wasm_type(it))
    }
    g.if_branch(ifexpr, expected, params, 0, existing_rvars)
}

pub fn (mut g Gen) match_expr(node ast.MatchExpr, expected ast.Type, existing_rvars []Var) {
    results := if expected == ast.void_type {
        []wasm.ValType{}
    } else if existing_rvars.len == 0 {
        g.unpack_type(expected).map(g.get_wasm_type(it))
    } else {
        g.unpack_type(expected).filter(!g.is_param_type(it)).map(g.get_wasm_type(it))
    }
    g.match_branch(node, expected, results, 0, existing_rvars)
}

fn (mut g Gen) match_branch(node ast.MatchExpr, expected ast.Type, unpacked_params []wasm.ValType, branch_idx int, existing_rvars []Var) {
    if branch_idx >= node.branches.len {
        return
    }

    branch := node.branches[branch_idx]
    mut is_last_branch := branch_idx + 1 >= node.branches.len
    mut has_else := branch.is_else

    if has_else {
        if branch.stmts.len > 0 {
            g.rvar_expr_stmts(branch.stmts, expected, existing_rvars)
        }
        return
    }

    if branch.exprs.len > 0 {
        g.match_branch_exprs(node, expected, unpacked_params, branch_idx, 0, existing_rvars, branch)
    } else {
        if branch.stmts.len > 0 {
            g.rvar_expr_stmts(branch.stmts, expected, existing_rvars)
        }
        if !is_last_branch {
            g.match_branch(node, expected, unpacked_params, branch_idx + 1, existing_rvars)
        }
    }
}

fn (mut g Gen) match_branch_exprs(node ast.MatchExpr, expected ast.Type, unpacked_params []wasm.ValType, branch_idx int, expr_idx int, existing_rvars []Var, branch ast.MatchBranch) {
    if expr_idx >= branch.exprs.len {
        return
    }

    mut is_last_branch := branch_idx + 1 >= node.branches.len
    mut is_last_expr := expr_idx + 1 >= branch.exprs.len

    expr := branch.exprs[expr_idx]

    if expr is ast.RangeExpr {
        wasm_type := g.as_numtype(g.get_wasm_type(node.cond_type))
        is_signed := node.cond_type.is_signed()

        g.expr(node.cond, node.cond_type)
        g.expr(expr.high, node.cond_type)
        g.func.le(wasm_type, is_signed)
    } else {
        if g.is_param_type(node.cond_type) {
            // Param types -> strings etc
            g.expr(node.cond, node.cond_type)
            g.expr(expr, node.cond_type)
            g.infix_from_typ(node.cond_type, .eq)
        } else {
            // Numeric types -> direct comparison
            wasm_type := g.as_numtype(g.get_wasm_type(node.cond_type))
            g.expr(node.cond, node.cond_type)
            g.expr(expr, node.cond_type)
            g.func.eq(wasm_type)
        }
    }

    blk := g.func.c_if([], unpacked_params)
    {
        if branch.stmts.len > 0 {
            g.rvar_expr_stmts(branch.stmts, expected, existing_rvars)
        }
    }
    {
        g.func.c_else(blk)
        if is_last_expr {
            if !is_last_branch {
                g.match_branch(node, expected, unpacked_params, branch_idx + 1, existing_rvars)
            }
        } else {
            g.match_branch_exprs(node, expected, unpacked_params, branch_idx, expr_idx + 1,
                existing_rvars, branch)
        }
    }
    g.func.c_end(blk)
}

// fn_value_functype lowers a V function type into the wasm function type used
// by `call_indirect`. It mirrors the parameter/return lowering done in `fn_decl`
// (a non-pure return becomes a leading rvar pointer parameter), so the computed
// type index matches the type the target function was committed with.
fn (mut g Gen) fn_value_functype(fn_typ ast.Type) wasm.FuncType {
    // final_sym unwraps any alias layer (e.g. `type Callback = fn (int) int`)
    ts := g.table.final_sym(fn_typ)
    if ts.info !is ast.FnType {
        g.w_error('fn_value_functype: `${ts.name}` is not a function type')
    }
    func := (ts.info as ast.FnType).func

    mut paraml := []wasm.ValType{}
    mut retl := []wasm.ValType{}

    rt := func.return_type
    if g.table.sym(rt).info is ast.MultiReturn {
        g.w_error('wasm backend: calling a function value with multiple return values is not yet supported')
    }
    if rt.has_flag(.option) || rt.has_flag(.result) {
        g.w_error('wasm backend: option/result function values are not yet supported')
    }
    if rt.idx() != ast.void_type_idx {
        wtyp := g.get_wasm_type(rt)
        if g.is_param_type(rt) {
            paraml << wtyp // non-pure return -> leading rvar pointer (i32)
        } else {
            retl << wtyp
        }
    }
    for p in func.params {
        paraml << g.get_wasm_type_int_literal(p.typ)
    }

    return wasm.FuncType{paraml, retl, none}
}

// push_fn_value evaluates the callee of a function-value call and leaves its
// i32 index into the indirect function table on the stack.
fn (mut g Gen) push_fn_value(node ast.CallExpr, fn_typ ast.Type) {
    if node.is_method {
        // a fn-typed struct field, e.g. `b.op` in `b.op(x)`: load the field
        g.expr(ast.SelectorExpr{
            expr:       node.left
            field_name: node.name
            expr_type:  node.left_type
            typ:        fn_typ
        }, fn_typ)
    } else if node.name == '' {
        // the callee is the expression itself, e.g. `(expr)(x)` or `make_cb()(x)`
        g.expr(node.left, fn_typ)
    } else if node.is_fn_a_const {
        // a const of function type. The const is registered in the global scope
        // under its fully-qualified name (`node.const_name`, e.g. `main.cb`), not
        // the lexical call name, so a plain `scope.find(node.name)` misses it.
        obj := g.table.global_scope.find(node.const_name) or {
            g.w_error('wasm: cannot resolve function const `${node.const_name}`')
        }
        v := g.get_var_from_ident(ast.Ident{
            name:  node.const_name
            scope: node.scope
            obj:   obj
        })
        g.get(v)
    } else {
        // a named local/param variable of function type
        obj := node.scope.find(node.name) or {
            g.w_error('wasm: cannot resolve function value `${node.name}`')
        }
        v := g.get_var_from_ident(ast.Ident{
            name:  node.name
            scope: node.scope
            obj:   obj
        })
        g.get(v)
    }
}

pub fn (mut g Gen) call_expr(node ast.CallExpr, expected ast.Type, existing_rvars []Var) {
    mut wasm_ns := ?string(none)
    mut name := node.name

    // Detect a call to a function value: either a fn-typed local/param/const
    // (is_fn_var/is_fn_a_const), a fn-typed struct field, which the checker
    // represents as a method call (`b.op()`), or an expression callee that
    // evaluates to a function (`make_cb()(x)`, `(expr)(x)`), which the checker
    // leaves with an empty name and a fn-typed `left_type`.
    mut is_fn_value := false
    mut fn_value_typ := ast.void_type
    if node.is_fn_var || node.is_fn_a_const {
        is_fn_value = true
        fn_value_typ = node.fn_var_type
    } else if node.is_method && node.left_type != 0 {
        if field := g.table.find_field(g.table.sym(node.left_type), node.name) {
            if g.table.final_sym(field.typ).info is ast.FnType {
                is_fn_value = true
                fn_value_typ = field.typ
            }
        }
    } else if node.name == '' && node.left_type != 0 {
        if g.table.final_sym(node.left_type).info is ast.FnType {
            is_fn_value = true
            fn_value_typ = node.left_type
        }
    }

    is_print := name in ['panic', 'println', 'print', 'eprintln', 'eprint']

    if node.is_method {
        name = '${g.table.get_type_name(node.receiver_type)}.${node.name}'
    }

    if node.language in [.js, .wasm] {
        cfn_attrs := unsafe { g.table.fns[node.name].attrs }

        short_name := if node.language == .js {
            node.name.all_after_last('JS.')
        } else {
            node.name.all_after_last('WASM.')
        }

        // setting a `?string` in a multireturn causes UNDEFINED BEHAVIOR AND STACK CORRUPTION
        // best to use a workaround till that is fixed

        mut wasm_ns_storage := ''
        wasm_ns_storage, name = g.get_ns_plus_name(short_name, cfn_attrs)
        wasm_ns = wasm_ns_storage
    }

    // callconv: {return structs} {method self} {arguments}

    // {return structs}
    //
    mut rvars := existing_rvars.clone()
    rts := g.unpack_type(node.return_type)
    if rvars.len == 0 && node.return_type != ast.void_type {
        for rt in rts {
            if g.is_param_type(rt) {
                v := g.new_local('', rt)
                rvars << v
            }
        }
    }
    for v in rvars {
        g.ref(v)
    }

    // {method self}
    //
    if node.is_method && !is_fn_value {
        expr := if !node.left_type.is_ptr() && node.receiver_type.is_ptr() { ast.Expr(ast.PrefixExpr{
                op:    .amp
                right: node.left
            }) } else { node.left }
        // hack alert!
        if node.receiver_type == ast.int_literal_type && expr is ast.IntegerLiteral {
            g.literal(expr.val, ast.i64_type)
        } else {
            g.expr(expr, node.receiver_type)
        }
    }

    // {callee}
    //
    // Evaluate the callee of a function-value call *before* its arguments, so a
    // callee with side effects (e.g. `make_box().op(next())`) keeps V's
    // left-to-right evaluation order. `call_indirect` wants the table index on
    // top of the stack (after the args), so stash it in a temp and reload it
    // once the arguments are in place.
    mut fn_value_idx := Var{}
    if is_fn_value {
        g.is_leaf_function = false
        g.uses_call_indirect = true
        fn_value_idx = g.new_local('', fn_value_typ)
        g.push_fn_value(node, fn_value_typ)
        g.set(fn_value_idx)
    }

    // {arguments}
    //
    for idx, arg in node.args {
        mut expr := arg.expr

        mut typ := arg.typ
        if is_print && typ != ast.string_type {
            has_str, _, _ := g.table.sym(typ).str_method_info()
            if typ != ast.string_type && !has_str {
                g.v_error('cannot implicitly convert as argument does not have a .str() function',
                    arg.pos)
            }

            expr = ast.CallExpr{
                name:           'str'
                left:           expr
                left_type:      typ
                receiver_type:  typ
                return_type:    ast.string_type
                is_method:      true
                is_return_used: true
            }
        }

        // another hack alert!
        if node.expected_arg_types[idx] == ast.int_literal_type && mut expr is ast.IntegerLiteral {
            g.literal(expr.val, ast.i64_type)
        } else {
            g.expr(expr, node.expected_arg_types[idx])
        }
    }

    if is_fn_value {
        // args are already on the stack; reload the callee's table index (computed
        // before the args, above) on top, then dispatch through the indirect table
        typeidx := g.mod.new_functype(g.fn_value_functype(fn_value_typ))
        g.get(fn_value_idx)
        g.func.call_indirect(typeidx, 0)
    } else if namespace := wasm_ns {
        // import calls won't touch `__vsp` !

        g.func.call_import(namespace, name)
    } else {
        // other calls may...
        g.is_leaf_function = false

        g.func.call(name)
    }

    if expected == ast.void_type && node.return_type != ast.void_type {
        for rt in rts { // order doesn't matter
            if !g.is_param_type(rt) {
                g.func.drop()
            }
        }
    } else if rvars.len > 0 && existing_rvars.len == 0 {
        mut rr_vars := []Var{cap: rts.len}
        mut r := rvars.len

        for rt in rts.reverse() {
            if !g.is_param_type(rt) {
                v := g.new_local('', rt)
                rr_vars << v
                g.set(v)
            } else {
                r--
                rr_vars << rvars[r]
            }
        }

        for v in rr_vars.reverse() {
            g.get(v)
        }
    }
    if node.is_noreturn {
        g.func.unreachable()
    }
}

pub fn (mut g Gen) get_field_offset(typ ast.Type, name string) int {
    ts := g.table.sym(typ)
    field := ts.find_field(name) or { g.w_error('could not find field `${name}` on init') }
    si := g.pool.type_struct_info(typ) or { panic('unreachable') }
    return si.offsets[field.i]
}

pub fn (mut g Gen) field_offset(typ ast.Type, name string) {
    offset := g.get_field_offset(typ, name)
    if offset != 0 {
        g.func.i32_const(i32(offset))
        g.func.add(.i32_t)
    }
}

pub fn (mut g Gen) load_field(typ ast.Type, ftyp ast.Type, name string) {
    offset := g.get_field_offset(typ, name)
    g.load(ftyp, offset)
}

pub fn (mut g Gen) store_field(typ ast.Type, ftyp ast.Type, name string) {
    offset := g.get_field_offset(typ, name)
    g.store(ftyp, offset)
}

pub fn (mut g Gen) expr(node ast.Expr, expected ast.Type) {
    match node {
        ast.ParExpr, ast.UnsafeExpr {
            g.expr(node.expr, expected)
        }
        ast.ArrayInit {
            v := g.new_local('', node.typ)
            g.set_with_expr(node, v)
            g.get(v)
        }
        ast.GoExpr {
            g.w_error('wasm backend does not support threads')
        }
        ast.IndexExpr {
            mut direct_array_access := g.is_direct_array_access || node.is_direct
            mut tmp_voidptr_var := wasm.LocalIndex(-1)

            // ptr + index * size
            mut typ := node.left_type
            ts := g.table.sym(typ)

            g.expr(node.left, node.left_type)
            if node.left_type == ast.string_type {
                if !direct_array_access {
                    tmp_voidptr_var = g.func.new_local_named(.i32_t, '__tmp<voidptr>')
                    g.func.local_tee(tmp_voidptr_var)
                }

                // be pedantic...
                g.load_field(ast.string_type, ast.voidptr_type, 'str')
                typ = ast.u8_type
            } else if typ.is_ptr() {
                typ = typ.deref()
                direct_array_access = true
            } else {
                match ts.info {
                    ast.Array {
                        g.w_error('wasm backend does not support dynamic arrays')
                    }
                    ast.ArrayFixed {
                        typ = ts.info.elem_type
                        if node.index.is_pure_literal() {
                            // checker would have gotten this by now
                            direct_array_access = true
                        }
                    }
                    else {
                        g.w_error('ast.IndexExpr: unreachable')
                    }
                }
            }

            size, _ := g.pool.type_size(typ)

            old_needs_address := g.needs_address
            g.needs_address = false
            g.expr(node.index, ast.int_type)
            g.needs_address = old_needs_address

            if !direct_array_access {
                g.is_leaf_function = false // calls panic()

                idx_temp := g.func.new_local_named(.i32_t, '__tmp<int>')
                g.func.local_tee(idx_temp)

                // .len
                if node.left_type == ast.string_type {
                    g.func.local_get(tmp_voidptr_var)
                    g.load_field(ast.string_type, ast.int_type, 'len')
                } else if ts.info is ast.ArrayFixed {
                    g.func.i32_const(i32(ts.info.size))
                } else {
                    panic('unreachable')
                }

                g.func.ge(.i32_t, false)
                // is_signed: false, negative numbers will be reinterpreted as > 2^31 and will also trigger false
                blk := g.func.c_if([], [])
                {
                    g.expr(ast.StringLiteral{ val: '${g.file_pos(node.pos)}: ${ast.Expr(node)}' },
                        ast.string_type)
                    g.func.call('eprintln')
                    g.expr(ast.StringLiteral{ val: 'index out of range' }, ast.string_type)
                    g.func.call('panic')
                }
                g.func.c_end(blk)

                g.func.local_get(idx_temp)
            }

            if size > 1 {
                g.literalint(size, ast.int_type)
                g.func.mul(.i32_t)
            }

            g.func.add(.i32_t)

            if !g.is_pure_type(typ) {
                return
            }

            if !g.needs_address {
                // ptr
                g.load(typ, 0)
            }
            g.cast(typ, expected)
        }
        ast.StructInit {
            v := g.new_local('', node.typ)
            g.set_with_expr(node, v)
            g.get(v)
        }
        ast.SelectorExpr {
            final := g.table.final_sym(node.expr_type)
            if node.field_name == 'len' && final.info is ast.ArrayFixed {
                // a fixed array's `.len` is a compile-time constant; the checker
                // types it as `int` but emits no field, so resolve it here rather
                // than aborting in get_field_offset ("could not find field len").
                g.func.i32_const(i32(final.info.size))
            } else if v := g.get_var_from_expr(node) {
                if g.needs_address {
                    if !v.is_address {
                        g.v_error("cannot take the address of a value that doesn't live on the stack. this is a current limitation.",
                            node.pos)
                    }
                    g.ref(v)
                } else {
                    g.get(v)
                }
            } else {
                g.needs_address = true
                {
                    g.expr(node.expr, node.typ)
                }
                g.needs_address = false
                g.field_offset(node.expr_type, node.field_name)
                if g.is_pure_type(node.typ) && !g.needs_address {
                    // expected to be a pointer
                    g.load(node.typ, 0)
                }
            }
            g.cast(node.typ, expected)
        }
        ast.MatchExpr {
            g.match_expr(node, expected, [])
        }
        ast.EnumVal {
            type_name := g.table.get_type_name(node.typ)
            ts_type := (g.table.sym(node.typ).info as ast.Enum).typ
            g.literalint(g.enum_vals[type_name].fields[node.val], ts_type)
        }
        ast.OffsetOf {
            sym := g.table.sym(node.struct_type)
            if sym.kind != .struct {
                g.v_error('__offsetof expects a struct Type as first argument', node.pos)
            }
            off := g.get_field_offset(node.struct_type, node.field)
            g.literalint(off, ast.u32_type)
        }
        ast.SizeOf {
            if !g.table.known_type_idx(node.typ) {
                g.v_error('unknown type `${*g.table.sym(node.typ)}`', node.pos)
            }
            size, _ := g.pool.type_size(node.typ)
            g.literalint(size, ast.u32_type)
        }
        ast.BoolLiteral {
            g.func.i32_const(i32(node.val))
        }
        ast.StringLiteral {
            if expected != ast.string_type {
                val := serialise.eval_escape_codes(node) or { panic('unreachable') }
                str_pos := g.pool.append_string(val)

                // c'str'
                g.literalint(g.data_base + str_pos, ast.voidptr_type)
                return
            }

            v := g.new_local('', ast.string_type)
            g.set_with_expr(node, v)
            g.get(v)
        }
        ast.StringInterLiteral {
            g.string_inter_literal_expr(node, expected)
        }
        ast.InfixExpr {
            g.infix_expr(node, expected)
        }
        ast.PrefixExpr {
            g.prefix_expr(node, expected)
        }
        ast.PostfixExpr {
            kind := if node.op == .inc { token.Kind.plus } else { token.Kind.minus }
            v := g.get_var_or_make_from_expr(node.expr, node.typ)

            g.set_prepare(v)
            {
                g.get(v)
                g.literalint(1, node.typ)
                g.handle_ptr_arithmetic(node.typ)
                g.infix_from_typ(node.typ, kind)
            }
            g.set_set(v)
        }
        ast.CharLiteral {
            rns := serialise.eval_escape_codes_raw(node.val) or { panic('unreachable') }.runes()[0]
            g.func.i32_const(i32(rns))
        }
        ast.Ident {
            if node.kind == .function {
                // a function used as a value: push its index into the
                // indirect function table (an i32)
                g.func.i32_const(i32(g.fn_table_index(node.name)))
            } else {
                v := g.get_var_from_ident(node)
                g.get(v)
                g.cast(v.typ, expected)
            }
        }
        ast.IntegerLiteral, ast.FloatLiteral {
            g.literal(node.val, expected)
        }
        ast.Nil {
            g.func.i32_const(0)
        }
        ast.EmptyExpr {}
        ast.IfExpr {
            g.if_expr(node, expected, [])
        }
        ast.CastExpr {
            // don't want to handle ast.int_literal_type
            if node.expr is ast.IntegerLiteral || node.expr is ast.FloatLiteral {
                g.expr(node.expr, node.typ)
                return
            }

            g.expr(node.expr, node.expr_type)

            // A cast involving a function value (e.g. `type Alias = fn (...)`) is an
            // i32 table index on both sides, so the value passes through unchanged.
            // Return before the numeric-cast path, which would also mis-handle a
            // function callee (`Alias(some_fn)`) as a variable in get_var_from_ident.
            if g.table.final_sym(node.typ).info is ast.FnType
                || g.table.final_sym(node.expr_type).info is ast.FnType {
                return
            }

            // TODO: unbelievable colossal hack
            mut typ := node.expr_type
            if node.expr is ast.Ident {
                v := g.get_var_from_ident(node.expr)
                if g.is_param(v) && node.expr_type == ast.int_literal_type {
                    typ = ast.i64_type
                }
            }

            g.func.cast(g.as_numtype(g.get_wasm_type(typ)), typ.is_signed(),
                g.as_numtype(g.get_wasm_type(node.typ)))
        }
        ast.CallExpr {
            g.call_expr(node, expected, [])
        }
        ast.AnonFn {
            if node.inherited_vars.len > 0 {
                // closures lower to runtime-generated executable memory, which
                // WebAssembly does not support efficiently yet; reject for now.
                g.v_error('closures (capturing anonymous functions) are not yet supported on the `wasm` backend',
                    node.decl.pos)
            }
            // compile the anon fn after the current toplevel stmts (when the
            // per-function state is clean again), then push its table index
            idx := g.fn_table_index(node.decl.name)
            if node.decl.name !in g.compiled_anon_fns {
                g.compiled_anon_fns[node.decl.name] = true
                g.pending_anon_fns << node.decl
            }
            g.func.i32_const(i32(idx))
        }
        else {
            g.w_error('wasm.expr(): unhandled node: ' + node.type_name())
        }
    }
}

pub fn (mut g Gen) for_in_stmt(node ast.ForInStmt) {
    if node.is_range {
        g.for_in_range(node)
        return
    }

    cond_sym := g.table.sym(node.cond_type)

    match cond_sym.kind {
        .array_fixed {
            g.for_in_array_fixed(node, cond_sym)
        }
        .string {
            g.for_in_string(node)
        }
        else {
            g.w_error('unsupported iter type: ${cond_sym.kind}')
        }
    }
}

fn (mut g Gen) for_in_range(node ast.ForInStmt) {
    loop_var_type := unpack_literal_int(node.val_type)
    block := g.func.c_block([], [])
    {
        mut loop_var := Var{}
        loop_var = g.new_local(node.val_var, loop_var_type)

        g.expr(node.cond, loop_var_type)
        g.set(loop_var)

        loop := g.func.c_loop([], [])
        {
            g.loop_breakpoint_stack << LoopBreakpoint{
                c_continue: loop
                c_break:    block
                name:       node.label
            }

            g.get(loop_var)
            g.expr(node.high, loop_var_type)
            wtyp := g.as_numtype(g.get_wasm_type(loop_var_type))
            g.func.lt(wtyp, loop_var_type.is_signed())
            g.func.eqz(.i32_t)
            g.func.c_br_if(block)

            g.expr_stmts(node.stmts, ast.void_type)

            g.set_prepare(loop_var)
            {
                g.get(loop_var)
                g.literalint(1, loop_var_type)
                g.func.add(wtyp)
            }
            g.set(loop_var)

            g.func.c_br(loop)
            g.loop_breakpoint_stack.pop()
        }
        g.func.c_end(loop)
    }
    g.func.c_end(block)
}

fn (mut g Gen) for_in_array_fixed(node ast.ForInStmt, cond_sym &ast.TypeSymbol) {
    info := cond_sym.info as ast.ArrayFixed
    array_size := info.size

    block := g.func.c_block([], [])
    {
        idx_var := g.new_local('__idx', ast.int_type)
        g.literalint(0, ast.int_type)
        g.set(idx_var)

        array_base := g.new_local('__array_base', node.cond_type)
        g.expr(node.cond, node.cond_type)
        g.set(array_base)

        loop := g.func.c_loop([], [])
        {
            g.loop_breakpoint_stack << LoopBreakpoint{
                c_continue: loop
                c_break:    block
                name:       node.label
            }

            // if index >= array_size
            g.get(idx_var)
            g.literalint(array_size, ast.int_type)
            g.func.ge(.i32_t, false)
            g.func.c_br_if(block)

            // _ -> No variable in the loop
            if node.val_var != '_' {
                element_var := g.new_local(node.val_var, node.val_type)

                // array_base + idx * element_size
                g.get(array_base)
                g.get(idx_var)

                elem_size, _ := g.pool.type_size(node.val_type)
                if elem_size > 1 {
                    g.literalint(elem_size, ast.int_type)
                    g.func.mul(.i32_t)
                }
                g.func.add(.i32_t)

                if g.is_pure_type(node.val_type) {
                    g.load(node.val_type, 0)
                }

                g.set(element_var)
            }

            // Inside loop
            g.expr_stmts(node.stmts, ast.void_type)

            // idx++
            g.set_prepare(idx_var)
            {
                g.get(idx_var)
                g.literalint(1, ast.int_type)
                g.func.add(.i32_t)
            }
            g.set(idx_var)

            g.func.c_br(loop)
            g.loop_breakpoint_stack.pop()
        }
        g.func.c_end(loop)
    }
    g.func.c_end(block)
}

fn (mut g Gen) for_in_string(node ast.ForInStmt) {
    block := g.func.c_block([], [])
    {
        idx_var := g.new_local('__idx', ast.int_type)
        g.literalint(0, ast.int_type)
        g.set(idx_var)

        // String ptr
        string_var := g.new_local('__string', ast.string_type)
        g.expr(node.cond, ast.string_type)
        g.set(string_var)

        len_var := g.new_local('__len', ast.int_type)
        g.get(string_var)
        g.load_field(ast.string_type, ast.int_type, 'len')
        g.set(len_var)

        loop := g.func.c_loop([], [])
        {
            g.loop_breakpoint_stack << LoopBreakpoint{
                c_continue: loop
                c_break:    block
                name:       node.label
            }

            // if index >= length
            g.get(idx_var)
            g.get(len_var)
            g.func.ge(.i32_t, false)
            g.func.c_br_if(block)

            // _ -> No variable in the loop
            if node.val_var != '_' {
                char_var := g.new_local(node.val_var, node.val_type)

                // Use string.at(idx) method to get the byte, don't reinvent the wheel
                g.get(string_var)
                g.get(idx_var)
                g.func.call('string.at')

                g.set(char_var)
            }

            // Inside loop
            g.expr_stmts(node.stmts, ast.void_type)

            // idx++
            g.set_prepare(idx_var)
            {
                g.get(idx_var)
                g.literalint(1, ast.int_type)
                g.func.add(.i32_t)
            }
            g.set(idx_var)

            g.func.c_br(loop)
            g.loop_breakpoint_stack.pop()
        }
        g.func.c_end(loop)
    }
    g.func.c_end(block)
}

pub fn (g &Gen) file_pos(pos token.Pos) string {
    return '${os.to_slash(g.file_path)}:${pos.line_nr + 1}:${pos.col + 1}'
}

pub fn (mut g Gen) expr_stmt(node ast.Stmt, expected ast.Type) {
    match node {
        ast.Block {
            g.expr_stmts(node.stmts, expected)
        }
        ast.Return {
            if node.exprs.len > 1 {
                g.set_with_multi_expr(ast.ConcatExpr{ vals: node.exprs }, g.ret, g.ret_rvars)
            } else if node.exprs.len == 1 {
                g.set_with_multi_expr(node.exprs[0], g.ret, g.ret_rvars)
            }
            g.func.c_br(g.ret_br)
        }
        ast.ExprStmt {
            g.expr(node.expr, expected)
        }
        ast.ForStmt {
            block := g.func.c_block([], [])
            {
                loop := g.func.c_loop([], [])
                {
                    g.loop_breakpoint_stack << LoopBreakpoint{
                        c_continue: loop
                        c_break:    block
                        name:       node.label
                    }

                    if !node.is_inf {
                        g.expr(node.cond, ast.bool_type)
                        g.func.eqz(.i32_t)
                        g.func.c_br_if(block) // !cond, goto end
                    }
                    g.expr_stmts(node.stmts, ast.void_type)
                    g.func.c_br(loop) // goto loop

                    g.loop_breakpoint_stack.pop()
                }
                g.func.c_end(loop)
            }
            g.func.c_end(block)
        }
        ast.ForCStmt {
            block := g.func.c_block([], [])
            {
                if node.has_init {
                    g.expr_stmt(node.init, ast.void_type)
                }

                loop := g.func.c_loop([], [])
                {
                    continue_block := g.func.c_block([], [])
                    {
                        g.loop_breakpoint_stack << LoopBreakpoint{
                            c_continue: continue_block
                            c_break:    block
                            name:       node.label
                        }

                        if node.has_cond {
                            g.expr(node.cond, ast.bool_type)
                            g.func.eqz(.i32_t)
                            g.func.c_br_if(block) // !cond, goto end
                        }

                        g.expr_stmts(node.stmts, ast.void_type)

                        g.loop_breakpoint_stack.pop()
                    }
                    g.func.c_end(continue_block)

                    if node.has_inc {
                        g.expr_stmt(node.inc, ast.void_type)
                    }

                    g.func.c_br(loop)
                }
                g.func.c_end(loop)
            }
            g.func.c_end(block)
        }
        ast.ForInStmt {
            g.for_in_stmt(node)
        }
        ast.BranchStmt {
            mut bp := g.loop_breakpoint_stack.last()
            if node.label != '' {
                for i := g.loop_breakpoint_stack.len; i > 0; {
                    i--
                    if g.loop_breakpoint_stack[i].name == node.label {
                        bp = g.loop_breakpoint_stack[i]
                    }
                }
            }

            if node.kind == .key_break {
                g.func.c_br(bp.c_break)
            } else {
                g.func.c_br(bp.c_continue)
            }
        }
        ast.DeferStmt {
            v := g.new_local('__defer(${node.idx_in_fn})', ast.bool_type)
            g.func.i32_const(1)
            g.set(v)
            g.defer_vars << v
        }
        ast.AssertStmt {
            if !node.is_used {
                return
            }

            // calls builtin functions, don't want to corrupt stack frame!
            g.is_leaf_function = false

            g.expr(node.expr, ast.bool_type)
            g.func.eqz(.i32_t) // !expr
            lbl := g.func.c_if([], [])
            {
                // main.main: ${msg}
                // V panic: Assertion failed...

                mut msg := '${g.file_pos(node.pos)}: fn ${g.fn_name}: ${ast.Stmt(node)}'
                if node.extra is ast.StringLiteral {
                    msg += ", '${node.extra.val}'"
                }

                g.expr(ast.StringLiteral{ val: msg }, ast.string_type)
                g.func.call('eprintln')
                g.expr(ast.StringLiteral{ val: 'Assertion failed...' }, ast.string_type)
                g.func.call('panic')
            }
            g.func.c_end(lbl)
        }
        ast.AssignStmt {
            if node.has_cross_var {
                g.w_error('complex assign statements are not implemented')
                // `a, b = b, a`
            } else {
                // `a := 1` | `a, b := 1, 2`
                // `a, b := foo()`
                // `a, b := if cond { 1, 2 } else { 3, 4 }`

                is_expr_assign := node.op !in [.decl_assign, .assign]

                // similar code from `call_expr()`
                // create variables or obtain them for use as rvals
                mut rvars := []Var{cap: node.left_types.len}
                for idx, rt in node.left_types {
                    left := node.left[idx]

                    mut var := Var{}
                    mut passed := false

                    if left is ast.Ident {
                        if left.kind == .blank_ident {
                            var = g.new_local('_', rt)
                            passed = true
                        } else if node.op == .decl_assign {
                            var = g.new_local(left.name, rt)
                            passed = true
                        }
                    }

                    if !passed {
                        if node.op == .assign {
                            if v := g.get_var_from_expr(left) {
                                var = v
                            }
                        } else if node.op == .plus_assign && g.is_param_type(rt) {
                            var = g.new_local('', rt)
                        }
                    }

                    if g.is_param_type(rt) {
                        rvars << var
                    }
                }

                mut set := false
                if node.right.len == 1 {
                    right := node.right[0]
                    match right {
                        ast.IfExpr {
                            params :=
                                node.left_types.filter(!g.is_param_type(it)).map(g.get_wasm_type(it))
                            g.if_branch(right, right.typ, params, 0, rvars)
                            set = true
                        }
                        ast.CallExpr {
                            g.call_expr(right, 0, rvars)
                            set = true
                        }
                        else {
                            // : set = false
                            // execute below instead
                        }
                    }
                }

                // will never be a multi expr
                // assume len == 1 for left and right
                if is_expr_assign {
                    left, right, typ := node.left[0], node.right[0], node.left_types[0]

                    rop := token.assign_op_to_infix_op(node.op)
                    lhs := g.get_var_or_make_from_expr(left, typ)

                    if !g.is_pure_type(lhs.typ) {
                        // main.struct.+
                        name := '${g.table.get_type_name(lhs.typ)}.${rop}'
                        g.ref(lhs)
                        g.ref(lhs)
                        g.expr(right, lhs.typ)
                        g.func.call(name)
                    } else {
                        g.set_prepare(lhs)
                        {
                            g.get(lhs)
                            g.expr(right, lhs.typ)
                            g.infix_from_typ(lhs.typ, rop)
                        }
                        g.set_set(lhs)
                    }

                    return
                }

                // prepare variables using expr()
                // if is an rvar, set it and ignore following
                if !set {
                    assert node.left.len == node.right.len
                    mut ridx := 0
                    for idx, right in node.right {
                        typ := node.left_types[idx]
                        if g.is_param_type(typ) {
                            g.set_with_expr(right, rvars[ridx])
                            ridx++
                        } else {
                            g.expr(right, typ)
                        }
                    }
                }

                for i := node.left.len; i > 0; {
                    i--
                    left := node.left[i]
                    typ := node.left_types[i]

                    if g.is_param_type(typ) {
                        // is already set
                        continue
                    }

                    if left is ast.Ident {
                        // `_ = expr`
                        if left.kind == .blank_ident {
                            // expression still may have side effect
                            g.func.drop()
                            continue
                        }
                    }

                    v := g.get_var_or_make_from_expr(left, typ)
                    g.set(v)
                }
            }
        }
        ast.AsmStmt {
            // assumed expected == void
            g.asm_stmt(node)
        }
        ast.EmptyStmt {
            // EmptyStmt nodes are emitted by earlier compiler passes for eliminated statements.
        }
        else {
            g.w_error('wasm.expr_stmt(): unhandled node: ' + node.type_name())
        }
    }
}

pub fn (mut g Gen) expr_stmts(stmts []ast.Stmt, expected ast.Type) {
    g.rvar_expr_stmts(stmts, expected, [])
}

pub fn (mut g Gen) rvar_expr_stmts(stmts []ast.Stmt, expected ast.Type, existing_rvars []Var) {
    for idx, stmt in stmts {
        if idx + 1 >= stmts.len {
            if stmt is ast.ExprStmt {
                g.set_with_multi_expr(stmt.expr, expected, existing_rvars)
            } else {
                g.expr_stmt(stmt, expected)
            }
        } else {
            g.expr_stmt(stmt, ast.void_type)
        }
    }
}

pub fn (mut g Gen) toplevel_stmt(node ast.Stmt) {
    match node {
        ast.FnDecl {
            g.fn_decl(node)
        }
        ast.Module {}
        ast.GlobalDecl {}
        ast.ConstDecl {}
        ast.Import {}
        ast.StructDecl {}
        ast.EnumDecl {}
        ast.TypeDecl {}
        else {
            g.w_error('wasm.toplevel_stmt(): unhandled node: ' + node.type_name())
        }
    }
}

pub fn (mut g Gen) toplevel_stmts(stmts []ast.Stmt) {
    for stmt in stmts {
        g.toplevel_stmt(stmt)
    }
}

struct Enum {
mut:
    fields map[string]i64
}

fn (mut g Gen) eval_enum_field_expr(expr ast.Expr) ?i64 {
    match expr {
        ast.IntegerLiteral {
            return expr.val.i64()
        }
        ast.CharLiteral {
            runes := expr.val.runes()
            if runes.len == 0 {
                return none
            }
            return i64(runes[0])
        }
        ast.BoolLiteral {
            return if expr.val { i64(1) } else { i64(0) }
        }
        ast.ParExpr {
            return g.eval_enum_field_expr(expr.expr)
        }
        ast.CastExpr {
            return g.eval_enum_field_expr(expr.expr)
        }
        ast.PrefixExpr {
            right := g.eval_enum_field_expr(expr.right)?
            match expr.op {
                .plus {
                    return right
                }
                .minus {
                    return -right
                }
                .bit_not {
                    return ~right
                }
                else {
                    return none
                }
            }
        }
        ast.InfixExpr {
            left := g.eval_enum_field_expr(expr.left)?
            right := g.eval_enum_field_expr(expr.right)?
            match expr.op {
                .plus {
                    return left + right
                }
                .minus {
                    return left - right
                }
                .mul {
                    return left * right
                }
                .div {
                    if right == 0 {
                        return none
                    }
                    return left / right
                }
                .mod {
                    if right == 0 {
                        return none
                    }
                    return left % right
                }
                .left_shift {
                    return i64(u64(left) << int(right))
                }
                .right_shift {
                    return left >> int(right)
                }
                .unsigned_right_shift {
                    return i64(u64(left) >> int(right))
                }
                .amp {
                    return left & right
                }
                .pipe {
                    return left | right
                }
                .xor {
                    return left ^ right
                }
                else {
                    return none
                }
            }
        }
        ast.Ident {
            mut obj := expr.obj
            if obj !in [ast.ConstField, ast.GlobalField] {
                obj = expr.scope.find(expr.name) or { return none }
            }
            match mut obj {
                ast.ConstField {
                    return g.eval_enum_field_expr(obj.expr)
                }
                ast.GlobalField {
                    return g.eval_enum_field_expr(obj.expr)
                }
                else {
                    return none
                }
            }
        }
        else {
            return none
        }
    }
}

pub fn (mut g Gen) calculate_enum_fields() {
    // `enum Enum as u64` is supported
    for name, decl in g.table.enum_decls {
        mut enum_vals := Enum{}
        mut value := if decl.is_flag { i64(1) } else { 0 }
        for field in decl.fields {
            if field.has_expr {
                value = g.eval_enum_field_expr(field.expr) or {
                    g.w_error('wasm: unsupported enum expression for `${name}.${field.name}`')
                }
            }
            enum_vals.fields[field.name] = value
            if decl.is_flag {
                value <<= 1
            } else {
                value++
            }
        }
        g.enum_vals[name] = enum_vals
    }
}

pub fn gen(files []&ast.File, mut table ast.Table, out_name string, w_pref &pref.Preferences) {
    stack_top := w_pref.wasm_stack_top
    mut g := &Gen{
        table:     table
        pref:      w_pref
        files:     files
        pool:      serialise.new_pool(table, store_relocs: true, null_terminated: false)
        stack_top: stack_top
        data_base: calc_align(stack_top + 1, 16)
    }
    g.mod.assign_memory('memory', true, 1, none)

    if g.pref.is_debug {
        g.mod.enable_debug(none)
    }

    g.calculate_enum_fields()
    for file in g.files {
        g.file_path = file.path
        if file.errors.len > 0 {
            util.verror('wasm error', file.errors[0].str())
        }
        g.toplevel_stmts(file.stmts)
    }
    g.housekeeping()

    mod := g.mod.compile()

    if out_name == '-' {
        if os.is_atty(1) == 1 {
            eprintln('pretty printing to stdout is not implemented for the time being')
            eprintln('raw bytes can mess up your terminal, are you piping into a file?')
            exit(1)
        } else {
            print(mod.bytestr())
        }
    }

    if out_name != '-' {
        os.write_file_array(out_name, mod) or { panic(err) }
        // The enabled feature set (Safari-15 floor plus any `-d` opt-in) drives
        // both validation and optimisation, so compute it once and share it.
        feats := g.enabled_wasm_features()
        if g.pref.wasm_validate {
            g.validate_wasm(out_name, feats)
        }
        if g.pref.is_prod {
            exe := $if windows { 'wasm-opt.exe' } $else { 'wasm-opt' }
            if rt := os.find_abs_path_of_executable(exe) {
                g.check_wasm_opt_version(rt)
                // -lmu: low memory unused, very important optimisation.
                // Feature flags are an explicit floor-safe allowlist (never `-all`),
                // so wasm-opt cannot silently introduce opcodes past the baseline.
                flags := binaryen_feature_flags(feats)
                res :=
                    os.execute('${os.quoted_path(rt)} ${flags} -lmu -c -O4 ${os.quoted_path(out_name)} -o ${os.quoted_path(out_name)}')
                if res.exit_code != 0 {
                    eprintln(res.output)
                    g.w_error('${rt} failed, this should not happen. Report an issue with the above messages, the webassembly generated, and appropriate code.')
                }
                // Re-validate AFTER optimisation: a passing pre-opt validation is
                // not sufficient, wasm-opt must not have introduced any opcode past
                // the enabled feature floor.
                if g.pref.wasm_validate {
                    g.validate_wasm(out_name, feats)
                }
            } else {
                g.w_error('${exe} not found! Try installing Binaryen.
                |    Run `./cmd/tools/install_binaryen.vsh`, to download a prebuilt executable for your platform.
                |    After that, either copy or symlink thirdparty/binaryen/bin/wasm-opt to a folder on your PATH,
                |    or add thirdparty/binaryen/bin to your PATH.
                |    Use `wasm-opt --version` to verify that it can be found.
                '.strip_margin())
            }
        }
    } else if g.pref.wasm_validate || g.pref.is_prod {
        eprintln('stdout output, cannot validate or optimise wasm')
    }
}

// validate_wasm runs `wasm-validate` over the emitted module at `out_name`,
// constraining it to the enabled feature set so that any opcode past the floor
// fails validation instead of passing under WABT's permissive defaults.
fn (mut g Gen) validate_wasm(out_name string, feats []WasmFeature) {
    exe := $if windows { 'wasm-validate.exe' } $else { 'wasm-validate' }
    if rt := os.find_abs_path_of_executable(exe) {
        mut p := os.new_process(rt)
        mut vargs := wabt_validate_args(feats)
        vargs << out_name
        p.set_args(vargs)
        p.set_redirect_stdio()
        p.run()
        err := p.stderr_slurp()
        p.wait()
        if p.code != 0 {
            eprintln(err)
            g.w_error('validation failed, this should not happen. report an issue with the above messages, the webassembly generated, and appropriate code.')
        }
    } else {
        g.w_error('${exe} not found! Try installing WABT (WebAssembly Binary Toolkit). Run `./cmd/tools/install_wabt.vsh`, to download a prebuilt executable for your platform.')
    }
}

// check_wasm_opt_version emits a soft warning if the resolved wasm-opt is older
// than the version the toolchain pins. It never fails the build (a hard pin with
// checksums belongs to the build/release pipeline, not the backend).
fn (mut g Gen) check_wasm_opt_version(exe string) {
    res := os.execute('${os.quoted_path(exe)} --version')
    if res.exit_code != 0 {
        return
    }
    // `wasm-opt --version` prints e.g. "wasm-opt version 108"
    ver := res.output.all_after_last(' ').trim_space().int()
    if ver != 0 && ver < wasm_opt_min_version {
        eprintln('warning: wasm-opt version ${ver} is older than the pinned minimum (${wasm_opt_min_version}); `-prod` output may differ. Run `./cmd/tools/install_binaryen.vsh` to update.')
    }
}