codegen_c.py

"""
voidc.codegen_c
===============
Stages 9-10 (IR lowering + Code Generator/Backend), combined for the
bootstrap compiler. Void's chosen compilation target is portable C99/C11
source, which is then handed to the system's C compiler (gcc/clang/MSVC)
to produce the final native executable -- see docs/05-ir-codegen-backend.md
for the full rationale. In short: C gives Void cross-platform native
codegen, an optimizing backend, and a linker *for free*, without the
bootstrap compiler having to implement register allocation, instruction
selection, or object-file emission itself. This is exactly the strategy
early compilers for C++ (cfront), Nim, and (originally) Eiffel used to
get off the ground quickly.

Responsibilities of this module:
  * Desugars high-level control flow (`foreach`, `do-while`, `switch`
    fallthrough, `match`) into C's primitive `for`/`while`/`switch`.
  * Performs monomorphization of user-defined generic functions/structs:
    every concrete instantiation encountered (`identity<int>(...)`,
    `Box<int>{...}`) is compiled to its own specialized C function/struct
    (name-mangled, e.g. `identity__i32`, `Box__i32`), exactly once
    (cached), mirroring what Rust/C++ templates do at a much simpler
    scale.
  * Instantiates built-in generic containers (Vector<T>, Map<K,V>,
    Set<T>, Option<T>, Result<T,E>) via C-macro "templates" defined in
    the runtime header -- `DEFINE_VEC(i32)` expands to a real `Vec_i32`
    struct + functions, which is a common, dependency-free way to get
    monomorphized generic containers in plain C.
  * Lowers closures to a `{fn_ptr, env_ptr}` pair (`VoidClosure`) plus a
    synthesized top-level function for the closure body and a heap
    struct holding the captured variables.
  * Emits `enum` as a C tagged union (`{ int32_t tag; union { ... }; }`)
    so `match` can be checked and payloads extracted safely.
  * Emits `class`/`struct` methods as plain C functions taking an
    explicit `self` pointer as the first parameter (the same lowering
    C++ itself uses under the hood).

This module intentionally works from the *untyped* AST (ast_nodes.py)
rather than sharing a typed tree with semantic.py -- see the module
docstring in semantic.py for why the bootstrap compiler keeps these
decoupled. It performs its own light, local type derivation
(`_infer_ctype`) sufficient to pick the right C operation (e.g. string
concatenation vs integer addition).
"""

import copy
from typing import List, Optional, Dict, Tuple, Any
from . import ast_nodes as A
from .errors import Diagnostics
from . import vtypes as T
PRIM_C = {
    "int": "int32_t", "i8": "int8_t", "i16": "int16_t", "i32": "int32_t", "i64": "int64_t",
    "u8": "uint8_t", "u16": "uint16_t", "u32": "uint32_t", "u64": "uint64_t",
    "float": "float", "f32": "float", "double": "double", "f64": "double",
    "bool": "bool", "char": "char", "byte": "uint8_t", "string": "VoidString",
    "void": "void",
}

PRIM_MANGLE = {
    "int": "i32", "i8": "i8", "i16": "i16", "i32": "i32", "i64": "i64",
    "u8": "u8", "u16": "u16", "u32": "u32", "u64": "u64",
    "float": "f32", "f32": "f32", "double": "f64", "f64": "f64",
    "bool": "bool", "char": "char", "byte": "u8", "string": "str", "void": "void",
}


class GenSym:
    def __init__(self):
        self.n = 0

    def next(self, prefix="tmp"):
        self.n += 1
        return f"__{prefix}{self.n}"


class CodeGen:
    def __init__(self, program: A.Program, symtab, diags: Diagnostics):
        self.prog = program
        self.symtab = symtab
        self.diags = diags
        self.gensym = GenSym()

        self.structs: Dict[str, A.StructDecl] = {}
        self.classes: Dict[str, A.ClassDecl] = {}
        self.enums: Dict[str, A.EnumDecl] = {}
        self.unions: Dict[str, A.UnionDecl] = {}
        self.fn_templates: Dict[str, A.FnDecl] = {}
        self.struct_templates: Dict[str, A.StructDecl] = {}
        self.plain_fns: List[A.FnDecl] = []

        self.builtin_generics_needed: set = set()   # ("Vec","i32") etc
        self.instantiated_fns: Dict[Tuple[str, Tuple[str, ...]], str] = {}
        self.instantiated_structs: Dict[Tuple[str, Tuple[str, ...]], str] = {}
        self.emitted_fn_bodies: List[str] = []
        self.emitted_struct_defs: List[str] = []
        self.closure_fns: List[str] = []

        self._collect_decls(program.decls)

    # ================================================================
    # Declaration collection
    # ================================================================
    def _collect_decls(self, decls):
        for d in decls:
            if isinstance(d, A.StructDecl):
                if d.generics:
                    self.struct_templates[d.name] = d
                else:
                    self.structs[d.name] = d
            elif isinstance(d, A.ClassDecl):
                self.classes[d.name] = d
            elif isinstance(d, A.EnumDecl):
                self.enums[d.name] = d
            elif isinstance(d, A.UnionDecl):
                self.unions[d.name] = d
            elif isinstance(d, A.FnDecl):
                if d.generics:
                    self.fn_templates[d.name] = d
                else:
                    self.plain_fns.append(d)
            elif isinstance(d, A.ModuleDecl):
                self._collect_decls(d.body)
            elif isinstance(d, A.ImplBlock):
                for m in d.methods:
                    m.owner = d.type_name
                    self.plain_fns.append(m)

    # ================================================================
    # Entry point
    # ================================================================
    def generate(self) -> str:
        out = []
        out.append(self._prelude())

        # Pass 1: scan the whole program to discover generic instantiations
        self._scan_program_for_instantiations()

        # Pass 2: emit builtin generic container instantiations
        for kind, args in sorted(self.builtin_generics_needed):
            out.append(self._emit_builtin_generic(kind, args))

        # Pass 3: emit enums (tagged unions)
        for name, decl in self.enums.items():
            out.append(self._emit_enum(decl))

        # Pass 4: emit plain (non-generic) structs & classes as C structs
        for name, decl in self.structs.items():
            out.append(self._emit_struct_typedef(decl.name, decl.fields))
        for name, decl in self.classes.items():
            out.append(self._emit_struct_typedef(decl.name, decl.fields, base=decl.base))

        # generic struct instantiations were appended to emitted_struct_defs
        # during the scan pass; splice them in after their (possible) base types
        out.extend(self.emitted_struct_defs)

        # Pass 5: forward-declare all free functions + methods
        for fn in self.plain_fns:
            out.append(self._fn_signature(fn) + ";")
        for cls in self.classes.values():
            for ctor in cls.constructors:
                out.append(self._ctor_signature(cls, ctor) + ";")
        out.append("")

        # Pass 6: emit monomorphized generic function bodies (collected during scan)
        out.extend(self.emitted_fn_bodies)

        # Pass 7: emit closures synthesized during scan
        out.extend(self.closure_fns)

        # Pass 8: emit real function/method/constructor bodies
        for fn in self.plain_fns:
            out.append(self._emit_fn(fn))
        for cls in self.classes.values():
            for ctor in cls.constructors:
                out.append(self._emit_ctor(cls, ctor))

        # Pass 9: emit `main` wrapper, if user defined `fn main`
        user_main = next((fn for fn in self.plain_fns if fn.name == "main"), None)
        if user_main is not None:
            ret = self.c_type(user_main.return_type) if user_main.return_type else "void"
            if ret == "void":
                out.append("int main(void) { void_main(); return 0; }")
            else:
                out.append(f"int main(void) {{ return (int)void_main(); }}")

        return "\n".join(out)

    # ================================================================
    # Prelude / runtime include
    # ================================================================
    def _prelude(self) -> str:
        return (
            '#include "void_runtime.h"\n'
            "// ---- Generated by voidc (Void reference bootstrap compiler) ----\n"
        )

    # ================================================================
    # Type mapping: ast TypeExpr -> C type string  (+ mangle string)
    # ================================================================
    def c_type(self, te: Optional[A.TypeExpr]) -> str:
        if te is None:
            return "void"
        if te.name == "fn":
            return "VoidClosure"
        base = None
        if te.name in PRIM_C:
            base = PRIM_C[te.name]
        elif te.name in self.struct_templates and te.args:
            base = self._instantiate_struct(te.name, te.args)
        elif te.name in ("Vector", "List"):
            elem = self.mangle_type(te.args[0]) if te.args else "i32"
            self.builtin_generics_needed.add(("Vec", (elem,)))
            base = f"Vec_{elem}"
        elif te.name == "Map":
            k = self.mangle_type(te.args[0]) if len(te.args) > 0 else "i32"
            v = self.mangle_type(te.args[1]) if len(te.args) > 1 else "i32"
            self.builtin_generics_needed.add(("Map", (k, v)))
            base = f"Map_{k}_{v}"
        elif te.name == "Set":
            elem = self.mangle_type(te.args[0]) if te.args else "i32"
            self.builtin_generics_needed.add(("Set", (elem,)))
            base = f"Set_{elem}"
        elif te.name == "Option":
            elem = self.mangle_type(te.args[0]) if te.args else "i32"
            self.builtin_generics_needed.add(("Option", (elem,)))
            base = f"Option_{elem}"
        elif te.name == "Result":
            ok = self.mangle_type(te.args[0]) if len(te.args) > 0 else "i32"
            err = self.mangle_type(te.args[1]) if len(te.args) > 1 else "i32"
            self.builtin_generics_needed.add(("Result", (ok, err)))
            base = f"Result_{ok}_{err}"
        else:
            base = te.name  # struct/class/enum by name, or an unresolved generic param (shouldn't reach codegen)
        if te.is_optional:
            elem = self.mangle_type(te)
            # avoid infinite recursion: mangle without the optional flag
            te2 = copy.copy(te); te2.is_optional = False
            elem = self.mangle_type(te2)
            self.builtin_generics_needed.add(("Option", (elem,)))
            base = f"Option_{elem}"
        if te.is_array:
            if te.array_size is not None:
                return base  # handled specially at declaration site (T name[N])
            elem = self.mangle_type_noarray(te)
            self.builtin_generics_needed.add(("Vec", (elem,)))
            base = f"Vec_{elem}"
        if te.is_ptr or te.is_ref:
            base = base + "*"
        return base

    def mangle_type_noarray(self, te: A.TypeExpr) -> str:
        te2 = copy.copy(te)
        te2.is_array = False
        return self.mangle_type(te2)

    def mangle_type(self, te: A.TypeExpr) -> str:
        if te.name in PRIM_MANGLE and not te.args:
            m = PRIM_MANGLE[te.name]
        else:
            m = te.name
            if te.args:
                m += "_" + "_".join(self.mangle_type(a) for a in te.args)
        if te.is_array:
            m = f"arr{te.array_size or ''}_" + m
        if te.is_optional:
            m = "opt_" + m
        if te.is_ptr:
            m = "ptr_" + m
        return m

    # ================================================================
    # Scan pass: discover every generic instantiation needed
    # ================================================================
    def _scan_program_for_instantiations(self):
        def walk(node):
            if node is None:
                return
            if isinstance(node, A.Call) and isinstance(node.callee, A.Ident) and node.type_args:
                if node.callee.name in self.fn_templates:
                    self._instantiate_fn(node.callee.name, node.type_args)
            if isinstance(node, A.StructLit) and node.type_args:
                if node.type_name in self.struct_templates:
                    self._instantiate_struct(node.type_name, node.type_args)
            if isinstance(node, A.TypeExpr):
                if node.name in self.struct_templates and node.args:
                    self._instantiate_struct(node.name, node.args)
                elif node.name in ("Vector", "List", "Map", "Set", "Option", "Result"):
                    self.c_type(node)  # side-effect: registers builtin_generics_needed
            for fld in getattr(node, "__dataclass_fields__", {}):
                val = getattr(node, fld)
                if isinstance(val, list):
                    for item in val:
                        if hasattr(item, "__dataclass_fields__"):
                            walk(item)
                elif hasattr(val, "__dataclass_fields__"):
                    walk(val)

        for d in self.prog.decls:
            walk(d)

    # ================================================================
    # Generic function monomorphization
    # ================================================================
    def _instantiate_fn(self, name: str, type_args: List[A.TypeExpr]) -> str:
        mangled_args = tuple(self.mangle_type(a) for a in type_args)
        key = (name, mangled_args)
        if key in self.instantiated_fns:
            return self.instantiated_fns[key]
        template = self.fn_templates[name]
        subst = {g.name: type_args[i] for i, g in enumerate(template.generics)}
        specialized = self._substitute_fn(template, subst)
        specialized.name = name + "__" + "_".join(mangled_args)
        specialized.generics = []
        mangled_name = specialized.name
        self.instantiated_fns[key] = mangled_name
        self.emitted_fn_bodies.append(self._fn_signature(specialized) + ";")
        self.emitted_fn_bodies.append(self._emit_fn(specialized))
        return mangled_name

    def _instantiate_struct(self, name: str, type_args: List[A.TypeExpr]) -> str:
        mangled_args = tuple(self.mangle_type(a) for a in type_args)
        key = (name, mangled_args)
        if key in self.instantiated_structs:
            return self.instantiated_structs[key]
        template = self.struct_templates[name]
        subst = {g.name: type_args[i] for i, g in enumerate(template.generics)}
        mangled_name = name + "__" + "_".join(mangled_args)
        self.instantiated_structs[key] = mangled_name  # reserve name before recursing (handles self-reference)
        new_fields = [self._substitute_field(f, subst) for f in template.fields]
        self.emitted_struct_defs.append(self._emit_struct_typedef(mangled_name, new_fields))
        for m in template.methods:
            specialized = self._substitute_fn(m, subst)
            specialized.owner = mangled_name
            specialized.name = mangled_name + "_" + specialized.name
            self.emitted_fn_bodies.append(self._fn_signature(specialized) + ";")
            self.emitted_fn_bodies.append(self._emit_fn(specialized))
        return mangled_name

    def _substitute_type(self, te: A.TypeExpr, subst: Dict[str, A.TypeExpr]) -> A.TypeExpr:
        if te is None:
            return None
        if te.name in subst and not te.args:
            repl = copy.deepcopy(subst[te.name])
            repl.is_ref = repl.is_ref or te.is_ref
            repl.is_ptr = repl.is_ptr or te.is_ptr
            repl.is_array = repl.is_array or te.is_array
            repl.array_size = te.array_size if te.array_size is not None else repl.array_size
            repl.is_optional = repl.is_optional or te.is_optional
            return repl
        new = copy.copy(te)
        new.args = [self._substitute_type(a, subst) for a in te.args]
        if te.fn_params:
            new.fn_params = [self._substitute_type(p, subst) for p in te.fn_params]
        if te.fn_return:
            new.fn_return = self._substitute_type(te.fn_return, subst)
        return new

    def _substitute_field(self, f: A.FieldDecl, subst) -> A.FieldDecl:
        nf = copy.copy(f)
        nf.type = self._substitute_type(f.type, subst)
        return nf

    def _substitute_fn(self, fn: A.FnDecl, subst) -> A.FnDecl:
        new_fn = copy.deepcopy(fn)
        new_fn.params = [A.Param(name=p.name, type=self._substitute_type(p.type, subst), default=p.default)
                          for p in fn.params]
        new_fn.return_type = self._substitute_type(fn.return_type, subst)
        # Body: substitute types that appear in nested VarDecls/casts by walking
        self._substitute_types_in_stmt(new_fn.body, subst)
        return new_fn

    def _substitute_types_in_stmt(self, node, subst):
        if node is None:
            return
        if isinstance(node, A.TypeExpr):
            replaced = self._substitute_type(node, subst)
            node.__dict__.update(replaced.__dict__)
            return
        for fld in getattr(node, "__dataclass_fields__", {}):
            val = getattr(node, fld)
            if isinstance(val, list):
                for item in val:
                    if hasattr(item, "__dataclass_fields__"):
                        self._substitute_types_in_stmt(item, subst)
            elif hasattr(val, "__dataclass_fields__"):
                self._substitute_types_in_stmt(val, subst)

    # ================================================================
    # Struct / enum emission
    # ================================================================
    def _emit_struct_typedef(self, name: str, fields: List[A.FieldDecl], base: Optional[str] = None) -> str:
        lines = [f"typedef struct {name} {{"]
        if base:
            lines.append(f"    struct {base} __base;")
        for f in fields:
            lines.append(f"    {self._decl_field(f.name, f.type)};")
        if not fields and not base:
            lines.append("    char __opaque;")
        lines.append(f"}} {name};")
        return "\n".join(lines)

    def _decl_field(self, name: str, te: A.TypeExpr) -> str:
        if te.is_array and te.array_size is not None:
            elem_te = copy.copy(te); elem_te.is_array = False
            return f"{self.c_type(elem_te)} {name}[{te.array_size}]"
        return f"{self.c_type(te)} {name}"

    def _emit_enum(self, decl: A.EnumDecl) -> str:
        name = decl.name
        lines = [f"typedef enum {{"]
        for v in decl.variants:
            tagname = f"{name}_{v.name}"
            if v.value is not None:
                lines.append(f"    {tagname} = {v.value},")
            else:
                lines.append(f"    {tagname},")
        lines.append(f"}} {name}_Tag;")
        lines.append(f"typedef struct {name} {{")
        lines.append(f"    {name}_Tag tag;")
        has_payload = any(v.fields for v in decl.variants)
        if has_payload:
            lines.append("    union {")
            for v in decl.variants:
                if v.fields:
                    lines.append(f"        struct {{")
                    for i, ftype in enumerate(v.fields):
                        lines.append(f"            {self.c_type(ftype)} f{i};")
                    lines.append(f"        }} {v.name};")
            lines.append("    } data;")
        lines.append(f"}} {name};")
        # constructor helper functions: Name_Variant(args...)
        for v in decl.variants:
            params = ", ".join(f"{self.c_type(t)} f{i}" for i, t in enumerate(v.fields))
            lines.append(f"static inline {name} {name}_{v.name}({params}) {{")
            lines.append(f"    {name} __r; __r.tag = {name}_{v.name};")
            for i in range(len(v.fields)):
                lines.append(f"    __r.data.{v.name}.f{i} = f{i};")
            lines.append("    return __r;")
            lines.append("}")
        return "\n".join(lines)

    # ================================================================
    # Builtin generic containers (Vec/Map/Set/Option/Result) via C macros
    # ================================================================
    def _emit_builtin_generic(self, kind: str, args: Tuple[str, ...]) -> str:
        if kind == "Vec":
            (t,) = args
            return f"DEFINE_VOID_VEC({t})"
        if kind == "Option":
            (t,) = args
            return f"DEFINE_VOID_OPTION({t})"
        if kind == "Result":
            ok, err = args
            return f"DEFINE_VOID_RESULT({ok}, {err})"
        if kind == "Map":
            k, v = args
            return f"DEFINE_VOID_MAP({k}, {v})"
        if kind == "Set":
            (t,) = args
            return f"DEFINE_VOID_SET({t})"
        return ""

    # ================================================================
    # Function signature / body emission
    # ================================================================
    def _fn_signature(self, fn: A.FnDecl) -> str:
        ret = self.c_type(fn.return_type) if fn.return_type else "void"
        params = []
        if fn.owner and not fn.is_static:
            params.append(f"{fn.owner}* self")
        for p in fn.params:
            params.append(f"{self.c_type(p.type)} {p.name}")
        pname = self._c_fn_name(fn)
        if not params:
            params = ["void"]
        return f"{ret} {pname}({', '.join(params)})"

    def _c_fn_name(self, fn: A.FnDecl) -> str:
        if fn.owner and fn.name != fn.owner + "_" + fn.name and not fn.name.startswith(fn.owner + "_"):
            if "__" in fn.name and fn.owner in fn.name:
                return fn.name
            return f"{fn.owner}_{fn.name}"
        if fn.name == "main":
            return "void_main"
        return fn.name

    def _ctor_signature(self, cls: A.ClassDecl, ctor: A.FnDecl) -> str:
        params = [f"{self.c_type(p.type)} {p.name}" for p in ctor.params]
        if not params:
            params = ["void"]
        return f"{cls.name} {cls.name}_new({', '.join(params)})"

    def _emit_ctor(self, cls: A.ClassDecl, ctor: A.FnDecl) -> str:
        env = {p.name: p.type for p in ctor.params}
        body_lines = [f"{self._ctor_signature(cls, ctor)} {{"]
        body_lines.append(f"    {cls.name} self_val;")
        body_lines.append("    memset(&self_val, 0, sizeof(self_val));")
        body_lines.append(f"    {cls.name}* self = &self_val;")
        for f in cls.fields:
            if f.default is not None:
                body_lines.append(f"    self->{f.name} = {self.emit_expr(f.default, env)};")
        for s in ctor.body.stmts:
            body_lines.append(self.emit_stmt(s, env, indent=1))
        body_lines.append("    return self_val;")
        body_lines.append("}")
        return "\n".join(body_lines)

    def _emit_fn(self, fn: A.FnDecl) -> str:
        if fn.body is None:
            return ""
        env: Dict[str, A.TypeExpr] = {}
        if fn.owner and not fn.is_static:
            env["self"] = A.TypeExpr(name=fn.owner, is_ptr=True)
        for p in fn.params:
            env[p.name] = p.type
        lines = [self._fn_signature(fn) + " {"]
        for s in fn.body.stmts:
            lines.append(self.emit_stmt(s, env, indent=1))
        lines.append("}")
        return "\n".join(lines)

    # ================================================================
    # Statement emission
    # ================================================================
    def emit_stmt(self, s: A.Stmt, env: Dict[str, A.TypeExpr], indent: int) -> str:
        pad = "    " * indent
        if isinstance(s, A.VarDecl):
            t = s.type if s.type is not None else self._infer_ctype(s.value, env)
            env[s.name] = t
            if s.type is not None and s.type.is_array and s.type.array_size is not None:
                elem_te = copy.copy(s.type); elem_te.is_array = False
                if s.value is not None and isinstance(s.value, A.ArrayLit):
                    inits = ", ".join(self.emit_expr(e, env) for e in s.value.elements)
                    return f"{pad}{self.c_type(elem_te)} {s.name}[{s.type.array_size}] = {{ {inits} }};"
                return f"{pad}{self.c_type(elem_te)} {s.name}[{s.type.array_size}];"
            init = f" = {self.emit_expr(s.value, env)}" if s.value is not None else ""
            return f"{pad}{self.c_type(t)} {s.name}{init};"
        if isinstance(s, A.ExprStmt):
            return f"{pad}{self.emit_expr(s.expr, env)};"
        if isinstance(s, A.ReturnStmt):
            if s.value is None:
                return f"{pad}return;"
            return f"{pad}return {self.emit_expr(s.value, env)};"
        if isinstance(s, A.BreakStmt):
            return f"{pad}break;"
        if isinstance(s, A.ContinueStmt):
            return f"{pad}continue;"
        if isinstance(s, A.Block):
            inner = dict(env)
            body = "\n".join(self.emit_stmt(x, inner, indent + 1) for x in s.stmts)
            return f"{pad}{{\n{body}\n{pad}}}"
        if isinstance(s, A.IfStmt):
            cond = self.emit_expr(s.cond, env)
            then_env = dict(env)
            then_body = "\n".join(self.emit_stmt(x, then_env, indent + 1) for x in s.then_branch.stmts)
            out = f"{pad}if ({cond}) {{\n{then_body}\n{pad}}}"
            if s.else_branch is not None:
                if isinstance(s.else_branch, A.IfStmt):
                    out += f" else {self.emit_stmt(s.else_branch, dict(env), indent).lstrip()}"
                else:
                    else_env = dict(env)
                    else_body = "\n".join(self.emit_stmt(x, else_env, indent + 1) for x in s.else_branch.stmts)
                    out += f" else {{\n{else_body}\n{pad}}}"
            return out
        if isinstance(s, A.WhileStmt):
            cond = self.emit_expr(s.cond, env)
            body_env = dict(env)
            body = "\n".join(self.emit_stmt(x, body_env, indent + 1) for x in s.body.stmts)
            return f"{pad}while ({cond}) {{\n{body}\n{pad}}}"
        if isinstance(s, A.DoWhileStmt):
            body_env = dict(env)
            body = "\n".join(self.emit_stmt(x, body_env, indent + 1) for x in s.body.stmts)
            cond = self.emit_expr(s.cond, env)
            return f"{pad}do {{\n{body}\n{pad}}} while ({cond});"
        if isinstance(s, A.ForStmt):
            inner = dict(env)
            init = self.emit_stmt(s.init, inner, 0).rstrip(";\n").strip() if s.init else ""
            cond = self.emit_expr(s.cond, inner) if s.cond else ""
            step_stmt = self.emit_stmt(s.step, inner, 0).rstrip(";\n").strip() if s.step else ""
            body = "\n".join(self.emit_stmt(x, inner, indent + 1) for x in s.body.stmts)
            return f"{pad}for ({init}; {cond}; {step_stmt}) {{\n{body}\n{pad}}}"
        if isinstance(s, A.ForeachStmt):
            return self._emit_foreach(s, env, indent)
        if isinstance(s, A.SwitchStmt):
            return self._emit_switch(s, env, indent)
        if isinstance(s, A.FnDecl):
            return ""  # nested fn decls not supported in this bootstrap subset
        return f"{pad}/* unhandled stmt {type(s).__name__} */"

    def _emit_foreach(self, s: A.ForeachStmt, env, indent):
        pad = "    " * indent
        it_type = self._infer_ctype(s.iterable, env)
        idx = s.index_name or self.gensym.next("i")
        iterable_expr = self.emit_expr(s.iterable, env)
        inner = dict(env)
        if it_type is not None and it_type.is_array and it_type.array_size is not None:
            elem_te = copy.copy(it_type); elem_te.is_array = False
            inner[s.var_name] = elem_te
            n = it_type.array_size
            body_lines = [f"{pad}    {self.c_type(elem_te)} {s.var_name} = {iterable_expr}[{idx}];"]
            body_lines += [self.emit_stmt(x, inner, indent + 1) for x in s.body.stmts]
            body = "\n".join(body_lines)
            return f"{pad}for (int64_t {idx} = 0; {idx} < {n}; {idx}++) {{\n{body}\n{pad}}}"
        else:
            elem_te = A.TypeExpr(name="int")
            if it_type is not None:
                te2 = copy.copy(it_type); te2.is_array = False
                elem_te = te2
            inner[s.var_name] = elem_te
            body_lines = [f"{pad}    {self.c_type(elem_te)} {s.var_name} = {iterable_expr}.data[{idx}];"]
            body_lines += [self.emit_stmt(x, inner, indent + 1) for x in s.body.stmts]
            body = "\n".join(body_lines)
            return f"{pad}for (int64_t {idx} = 0; {idx} < {iterable_expr}.len; {idx}++) {{\n{body}\n{pad}}}"

    def _emit_switch(self, s: A.SwitchStmt, env, indent):
        pad = "    " * indent
        subj = self.emit_expr(s.subject, env)
        lines = [f"{pad}switch ({subj}) {{"]
        for case in s.cases:
            if not case.values:
                lines.append(f"{pad}default: {{")
            else:
                for v in case.values:
                    lines.append(f"{pad}case {self.emit_expr(v, env)}:")
                lines.append(f"{pad}{{")
            inner = dict(env)
            for x in case.body.stmts:
                lines.append(self.emit_stmt(x, inner, indent + 1))
            lines.append(f"{pad}    break;")
            lines.append(f"{pad}}}")
        lines.append(f"{pad}}}")
        return "\n".join(lines)

    # ================================================================
    # Expression emission
    # ================================================================
    def emit_expr(self, e: A.Expr, env: Dict[str, A.TypeExpr]) -> str:
        if isinstance(e, A.IntLit):
            return str(e.value)
        if isinstance(e, A.FloatLit):
            return repr(e.value)
        if isinstance(e, A.BoolLit):
            return "true" if e.value else "false"
        if isinstance(e, A.StringLit):
            escaped = e.value.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n")
            return f'void_string_lit("{escaped}")'
        if isinstance(e, A.CharLit):
            c = e.value.replace("'", "\\'")
            return f"'{c}'"
        if isinstance(e, A.NullLit):
            return "NULL"
        if isinstance(e, A.Ident):
            return "self" if e.name == "self" else e.name
        if isinstance(e, A.RefExpr):
            return f"(&{self.emit_expr(e.value, env)})"
        if isinstance(e, A.DerefExpr):
            return f"(*{self.emit_expr(e.value, env)})"
        if isinstance(e, A.UnaryOp):
            v = self.emit_expr(e.operand, env)
            if e.postfix:
                return f"({v}{e.op})"
            return f"({e.op}{v})"
        if isinstance(e, A.BinOp):
            return self._emit_binop(e, env)
        if isinstance(e, A.Ternary):
            return f"({self.emit_expr(e.cond, env)} ? {self.emit_expr(e.then_expr, env)} : {self.emit_expr(e.else_expr, env)})"
        if isinstance(e, A.Assign):
            t = self.emit_expr(e.target, env)
            v = self.emit_expr(e.value, env)
            return f"({t} {e.op} {v})"
        if isinstance(e, A.CastExpr):
            return f"(({self.c_type(e.target)}){self.emit_expr(e.value, env)})"
        if isinstance(e, A.Call):
            return self._emit_call(e, env)
        if isinstance(e, A.Index):
            ot = self._infer_ctype(e.obj, env)
            obj = self.emit_expr(e.obj, env)
            idx = self.emit_expr(e.index, env)
            if ot is not None and ot.is_array and ot.array_size is not None:
                return f"{obj}[{idx}]"
            return f"{obj}.data[{idx}]"
        if isinstance(e, A.Field):
            return self._emit_field(e, env)
        if isinstance(e, A.ArrayLit):
            inits = ", ".join(self.emit_expr(x, env) for x in e.elements)
            return f"{{ {inits} }}"
        if isinstance(e, A.StructLit):
            tname = e.type_name
            if e.type_args:
                tname = self._instantiate_struct(e.type_name, e.type_args)
            parts = ", ".join(f".{k} = {self.emit_expr(v, env)}" for k, v in e.fields.items())
            return f"(({tname}){{ {parts} }})"
        if isinstance(e, A.Lambda):
            return self._emit_lambda(e, env)
        if isinstance(e, A.MatchExpr):
            return self._emit_match_as_expr(e, env)
        return "/* expr */0"

    def _emit_binop(self, e: A.BinOp, env) -> str:
        lt = self._infer_ctype(e.left, env)
        if e.op == "+" and lt is not None and lt.name == "string":
            return f"void_string_concat({self.emit_expr(e.left, env)}, {self.emit_expr(e.right, env)})"
        l = self.emit_expr(e.left, env)
        r = self.emit_expr(e.right, env)
        return f"({l} {e.op} {r})"

    def _emit_field(self, e: T.ArrayType, env):
        obj_t = self._infer_ctype(e.obj, env)
        obj = self.emit_expr(e.obj, env)

    # Fixed arrays
        if isinstance(obj_t, T.ArrayType):
            if e.name == "size":
                return str(obj_t.size)

    # Vector/List
        if isinstance(obj_t, T.NamedType):
            if obj_t.name in ("Vector", "List") and e.name == "size":
                return f"{obj}.len"

        arrow = obj_t is not None and (obj_t.is_ptr or obj_t.is_ref)
        sep = "->" if arrow else "."
        return f"{obj}{sep}{e.name}"

    def _emit_call(self, e: A.Call, env) -> str:
        if isinstance(e.callee, A.Ident):
            name = e.callee.name
            if e.type_args and name in self.fn_templates:
                mangled = self._instantiate_fn(name, e.type_args)
                args = ", ".join(self.emit_expr(a, env) for a in e.args)
                return f"{mangled}({args})"
            if name in ("print", "println"):
                return self._emit_print(e, env, newline=(name == "println"))
            if name == "input":
                if e.args:
                    prompt = self.emit_expr(e.args[0], env)
                    return f"(void_print_string({prompt}), void_input_line())"
                return "void_input_line()"
            if name == "toInt":
                a = e.args[0]
                at = self._infer_ctype(a, env)
                av = self.emit_expr(a, env)
                if at is not None and at.name == "string":
                    return f"void_string_to_int({av})"
                return f"((int64_t)({av}))"
            if name == "toFloat":
                a = e.args[0]
                at = self._infer_ctype(a, env)
                av = self.emit_expr(a, env)
                if at is not None and at.name == "string":
                    return f"void_string_to_float({av})"
                return f"((double)({av}))"
            if name == "toString":
                a = e.args[0]
                at = self._infer_ctype(a, env)
                av = self.emit_expr(a, env)
                if at is not None and at.name in ("float", "f32", "double", "f64"):
                    return f"void_float_to_string((double)({av}))"
                if at is not None and at.name == "string":
                    return av
                return f"void_int_to_string((int64_t)({av}))"
            if name in ("sqrt", "floor", "ceil", "pow", "sin", "cos", "tan", "log", "log10", "exp"):
                args = ", ".join(f"(double)({self.emit_expr(a, env)})" for a in e.args)
                return f"{name}({args})"
            if name == "abs":
                a = e.args[0]
                at = self._infer_ctype(a, env)
                av = self.emit_expr(a, env)
                if at is not None and at.name in ("float", "f32", "double", "f64"):
                    return f"fabs((double)({av}))"
                return f"llabs((long long)({av}))"
            if name in ("min", "max"):
                op = "<" if name == "min" else ">"
                a, b = (self.emit_expr(x, env) for x in e.args[:2])
                return f"(({a}) {op} ({b}) ? ({a}) : ({b}))"
            if name == "len":
                a = e.args[0]
                at = self._infer_ctype(a, env)
                av = self.emit_expr(a, env)
                if at is not None and at.is_array and at.array_size is not None:
                    return str(at.array_size)
                if at is not None and at.name == "string":
                    return f"{av}.len"
                return f"{av}.len"
            if name == "assert":
                cond = self.emit_expr(e.args[0], env)
                msg = self.emit_expr(e.args[1], env) if len(e.args) > 1 else f'void_string_lit("assertion failed")'
                return f"void_assert({cond}, {msg})"
            args = ", ".join(self.emit_expr(a, env) for a in e.args)
            return f"{name}({args})"
        if isinstance(e.callee, A.Field):
            obj_t = self._infer_ctype(e.callee.obj, env)
            obj = self.emit_expr(e.callee.obj, env)
            method = e.callee.name
            owner = obj_t.name if obj_t is not None else None
            args = [obj if (obj_t and (obj_t.is_ptr or obj_t.is_ref)) else f"(&{obj})"]
            args += [self.emit_expr(a, env) for a in e.args]
            fname = f"{owner}_{method}" if owner else method
            return f"{fname}({', '.join(args)})"
        callee = self.emit_expr(e.callee, env)
        args = ", ".join(self.emit_expr(a, env) for a in e.args)
        return f"{callee}({args})"

    def _emit_print(self, e: A.Call, env, newline: bool) -> str:
        parts = []
        for a in e.args:
            t = self._infer_ctype(a, env)
            v = self.emit_expr(a, env)
            if t is None or t.name in ("int", "i8", "i16", "i32", "i64"):
                parts.append(f'void_print_i64((int64_t)({v}))')
            elif t.name in ("u8", "u16", "u32", "u64", "byte"):
                parts.append(f'void_print_u64((uint64_t)({v}))')
            elif t.name in ("float", "f32", "double", "f64"):
                parts.append(f'void_print_f64((double)({v}))')
            elif t.name == "bool":
                parts.append(f'void_print_bool({v})')
            elif t.name == "char":
                parts.append(f'void_print_char({v})')
            elif t.name == "string":
                parts.append(f'void_print_string({v})')
            else:
                parts.append(f'void_print_string(void_string_lit("<{t.name}>"))')
        if newline:
            parts.append("void_print_char('\\n')")
        body = ", ".join(parts)
        return f"({body})"

    def _emit_match_as_expr(self, e: A.MatchExpr, env) -> str:
        # Desugar match-as-expression into an immediately-invoked statement
        # expression (GNU C extension), which keeps codegen simple while
        # still letting `match` be used where a value is expected.
        subj_t = self._infer_ctype(e.subject, env)
        subj_var = self.gensym.next("m")
        lines = [f"({{ {self.c_type(subj_t)} {subj_var} = {self.emit_expr(e.subject, env)};"]
        result_ty = "int64_t"
        lines.append(f"  {result_ty} __mres = 0;")
        for arm in e.arms:
            inner = dict(env)
            cond, binds = self._pattern_cond(arm.pattern, subj_var, subj_t, inner)
            lines.append(f"  if ({cond}) {{ {binds}")
            if isinstance(arm.body, A.Block):
                for st in arm.body.stmts:
                    lines.append("    " + self.emit_stmt(st, inner, 0))
            else:
                lines.append(f"    __mres = (int64_t)({self.emit_expr(arm.body, inner)});")
            lines.append("  } else ")
        lines.append("  {}")
        lines.append(f"  __mres; }})")
        return "\n".join(lines)

    def _pattern_cond(self, pattern, subj_var, subj_t, env):
        if isinstance(pattern, A.WildcardPattern):
            return "1", ""
        if isinstance(pattern, A.EnumPattern):
            tagname = f"{pattern.enum_name}_{pattern.variant}"
            cond = f"{subj_var}.tag == {tagname}"
            binds = []
            for i, b in enumerate(pattern.bindings):
                binds.append(f"__auto_type {b} = {subj_var}.data.{pattern.variant}.f{i};")
                env[b] = None
            return cond, " ".join(binds)
        # literal or ident-binding pattern
        if isinstance(pattern, A.Ident):
            env[pattern.name] = subj_t
            return "1", f"__auto_type {pattern.name} = {subj_var};"
        return f"({subj_var} == {self.emit_expr(pattern, env)})", ""

    def _emit_lambda(self, lam: A.Lambda, env) -> str:
        fn_name = self.gensym.next("lambda")
        capture_struct = fn_name + "_Env"
        captures = lam.captures or []
        cap_lines = [f"typedef struct {{"]
        for c in captures:
            ct = env.get(c)
            cap_lines.append(f"    {self.c_type(ct) if ct else 'int64_t'} {c};")
        cap_lines.append(f"}} {capture_struct};")
        self.closure_fns.append("\n".join(cap_lines))

        inner_env = dict(env)
        params_decl = []
        for p in lam.params:
            inner_env[p.name] = p.type
            params_decl.append(f"{self.c_type(p.type)} {p.name}")
        ret_te = lam.return_type
        ret_c = self.c_type(ret_te) if ret_te else "int64_t"
        sig = f"{ret_c} {fn_name}(void* __envp{(', ' + ', '.join(params_decl)) if params_decl else ''})"
        body_lines = [sig + " {"]
        if captures:
            body_lines.append(f"    {capture_struct}* __env = ({capture_struct}*)__envp;")
            for c in captures:
                inner_env.setdefault(c, env.get(c))
        for c in captures:
            body_lines.append(f"    {self.c_type(env.get(c)) if env.get(c) else 'int64_t'} {c} = __env->{c};")
        if isinstance(lam.body, A.Block):
            for st in lam.body.stmts:
                body_lines.append(self.emit_stmt(st, inner_env, 1))
        else:
            body_lines.append(f"    return {self.emit_expr(lam.body, inner_env)};")
        body_lines.append("}")
        self.closure_fns.append("\n".join(body_lines))

        env_var = self.gensym.next("env")
        alloc_lines = f"({capture_struct}*)malloc(sizeof({capture_struct}))"
        assigns = "; ".join(f"{env_var}->{c} = {c}" for c in captures)
        # Build an inline statement-expression that allocates env, fills it, and returns a VoidClosure
        return (f"({{ {capture_struct}* {env_var} = {alloc_lines}; "
                f"{(assigns + ';') if captures else ''} "
                f"(VoidClosure){{ .fn = (void*){fn_name}, .env = {env_var} }}; }})")

    # ================================================================
    # Minimal local type derivation (for codegen decisions only)
    # ================================================================
    def _infer_ctype(self, e: A.Expr, env: Dict[str, A.TypeExpr]) -> Optional[A.TypeExpr]:
        if e is None:
            return None
        if isinstance(e, A.IntLit):
            return A.TypeExpr(name="int")
        if isinstance(e, A.FloatLit):
            return A.TypeExpr(name="double")
        if isinstance(e, A.BoolLit):
            return A.TypeExpr(name="bool")
        if isinstance(e, A.StringLit):
            return A.TypeExpr(name="string")
        if isinstance(e, A.CharLit):
            return A.TypeExpr(name="char")
        if isinstance(e, A.Ident):
            return env.get(e.name)
        if isinstance(e, A.RefExpr):
            inner = self._infer_ctype(e.value, env)
            if inner is None:
                return None
            r = copy.copy(inner); r.is_ref = True
            return r
        if isinstance(e, A.DerefExpr):
            inner = self._infer_ctype(e.value, env)
            if inner is None:
                return None
            r = copy.copy(inner); r.is_ptr = False; r.is_ref = False
            return r
        if isinstance(e, A.BinOp):
            if e.op in ("==", "!=", "<", ">", "<=", ">=", "&&", "||"):
                return A.TypeExpr(name="bool")
            return self._infer_ctype(e.left, env) or self._infer_ctype(e.right, env)
        if isinstance(e, A.UnaryOp):
            if e.op == "!":
                return A.TypeExpr(name="bool")
            return self._infer_ctype(e.operand, env)
        if isinstance(e, A.Ternary):
            return self._infer_ctype(e.then_expr, env) or self._infer_ctype(e.else_expr, env)
        if isinstance(e, A.Assign):
            return self._infer_ctype(e.target, env)
        if isinstance(e, A.CastExpr):
            return e.target
        if isinstance(e, A.Index):
            ot = self._infer_ctype(e.obj, env)
            if ot is None:
                return None
            if ot.is_array:
                r = copy.copy(ot); r.is_array = False; r.array_size = None
                return r
            if ot.name == "string":
                return A.TypeExpr(name="char")
            return None
        if isinstance(e, A.Field):
            ot = self._infer_ctype(e.obj, env)
            if ot is None:
                return None
            owner = ot.name
            decl = self.structs.get(owner) or self.classes.get(owner)
            if decl:
                for f in decl.fields:
                    if f.name == e.name:
                        return f.type
            return None
        if isinstance(e, A.Call):
            if isinstance(e.callee, A.Ident):
                name = e.callee.name
                if name in ("input", "toString"):
                    return A.TypeExpr(name="string")
                if name == "toInt":
                    return A.TypeExpr(name="i64")
                if name in ("toFloat", "sqrt", "pow", "sin", "cos", "tan", "log", "log10", "exp"):
                    return A.TypeExpr(name="double")
                if name in ("floor", "ceil"):
                    return A.TypeExpr(name="double")
                if name in ("abs", "min", "max"):
                    return self._infer_ctype(e.args[0], env) if e.args else A.TypeExpr(name="int")
                if name in ("print", "println", "assert"):
                    return A.TypeExpr(name="void")
                if name in self.fn_templates and e.type_args:
                    return self._substitute_type(self.fn_templates[name].return_type,
                                                  {g.name: e.type_args[i] for i, g in enumerate(self.fn_templates[name].generics)})
                for fn in self.plain_fns:
                    if fn.name == name:
                        return fn.return_type
            if isinstance(e.callee, A.Field):
                ot = self._infer_ctype(e.callee.obj, env)
                owner = ot.name if ot else None
                decl = self.structs.get(owner) or self.classes.get(owner) if owner else None
                if decl:
                    for m in decl.methods:
                        if m.name == e.callee.name:
                            return m.return_type
            return None
        if isinstance(e, A.ArrayLit):
            elem = self._infer_ctype(e.elements[0], env) if e.elements else A.TypeExpr(name="int")
            r = copy.copy(elem) if elem else A.TypeExpr(name="int")
            r.is_array = True
            r.array_size = len(e.elements)
            return r
        if isinstance(e, A.StructLit):
            return A.TypeExpr(name=e.type_name if not e.type_args else self._instantiate_struct(e.type_name, e.type_args))
        return None