// Copyright (c) 2026 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module transformer

// Generic monomorphization belongs in the transformer so every backend receives
// concrete FnDecls and call names.
import v2.ast
import v2.token
import v2.types
import os
import time

struct CloneComptimeFieldCtx {
    var_name       string
    field          types.Field
    field_idx      int
    struct_type    types.Struct
    attrs          []string
    is_embed       bool
    continue_label string
    break_label    string
}

struct DeferredGenericCallSpec {
    base_name string
    bindings  map[string]types.Type
    file_idx  int
}

struct GenericStructSpec {
    base_c_name         string
    concrete_c_name     string
    concrete_short_name string
    module_name         string
    file_idx            int
    bindings            map[string]types.Type
}

struct GenericTypeArgCursorBindings {
    bindings      map[string]types.Type
    concrete_args []types.Type
}

struct StructDefaultDeclInfo {
    decl        ast.StructDecl
    module_name string
}

// needs_full_files_for_transform reports whether transform needs the whole
// legacy file set before per-file workers can run.
pub fn (t &Transformer) needs_full_files_for_transform() bool {
    return true
}

// prepare_files_for_transform performs whole-program preparation required
// before per-file transformation. Generic monomorphization lives here so
// sequential and parallel builders feed identical concrete ASTs to every
// backend.
pub fn (mut t Transformer) prepare_files_for_transform(files []ast.File) []ast.File {
    // The checker records generic bindings while checking generic bodies, which
    // can include speculative branches from unused library code. Build the
    // transformer worklist from concrete call sites instead, then scan concrete
    // clones to discover transitive generic calls.
    t.env.generic_types = map[string][]map[string]types.Type{}
    mut prepared := files.clone()
    t.collect_declared_method_fns(prepared)
    t.collect_struct_field_generic_decl_types(prepared)
    timing := os.getenv('V2_TTIME') != ''
    mut sw := time.new_stopwatch()
    // prepared_dirty tracks whether `prepared` changed since it was last scanned
    // by collect_generic_call_specs. collect is a pure (idempotent) function of
    // the program: scanning an unchanged file set rediscovers the exact same
    // specs. So the leading full-program scan is only needed when the program
    // actually changed since the previous scan — i.e. when the previous
    // iteration's inject step appended new struct specializations. The
    // post-mono_pass scan below already covers the clones mono_pass adds, so the
    // only unscanned source of change between iterations is inject. This removes
    // the fixpoint's redundant confirmation scan (~6s / ~700MB for v2 self-host).
    mut prepared_dirty := true
    for iter in 0 .. 64 {
        spec_count := t.monomorphized_specs.len
        generic_count := t.generic_types_spec_count()
        struct_count := t.generic_struct_specs.len
        ts_start := sw.elapsed().milliseconds()
        // collect1: full-program scan, only when the program changed since the
        // last scan (initial pass, or inject appended structs last iteration).
        if prepared_dirty {
            t.collect_generic_call_specs(prepared)
        }
        ts_collect1 := sw.elapsed().milliseconds()
        before_mono := t.monomorphized_specs.len
        prepared = t.monomorphize_pass(prepared)
        ts_mono := sw.elapsed().milliseconds()
        // collect2: only when monomorphize_pass materialized new clones. Those
        // clones are the only statements the previous scan has not seen — every
        // other statement is byte-for-byte unchanged and collect is idempotent —
        // so rescan just the new clones instead of re-walking all files. This
        // turns the dominant ~6s/~700MB full rescan into a walk of a few dozen
        // functions.
        if t.monomorphized_specs.len != before_mono {
            t.collect_generic_call_specs_in_new_clones(prepared)
        }
        ts_collect2 := sw.elapsed().milliseconds()
        prepared = t.inject_generic_struct_specializations(prepared)
        ts_inject := sw.elapsed().milliseconds()
        if t.inject_changed_files {
            t.collect_generic_call_specs_in_new_structs(prepared)
        }
        ts_collect3 := sw.elapsed().milliseconds()
        // collect2/collect3 rescan every statement appended by this iteration,
        // so the next iteration does not need another full-program scan.
        prepared_dirty = false
        if timing {
            eprintln('  [ttime] iter ${iter}: collect1=${ts_collect1 - ts_start}ms mono_pass=${ts_mono - ts_collect1}ms collect2=${ts_collect2 - ts_mono}ms inject=${ts_inject - ts_collect2}ms collect3=${ts_collect3 - ts_inject}ms files=${prepared.len}')
        }
        t_print_mem('monomorphize iter ${iter}')
        if t.monomorphized_specs.len == spec_count && t.generic_types_spec_count() == generic_count
            && t.generic_struct_specs.len == struct_count {
            break
        }
    }
    if dump_path := os.getenv_opt('V2_TDUMP') {
        t.dump_monomorphize_specs(dump_path, prepared)
    }
    t.collect_struct_default_decl_infos(prepared)
    t.collect_concrete_embedded_owner_names(prepared)
    return prepared
}

// prepare_flat_for_transform performs the same whole-program generic
// preparation as prepare_files_for_transform, but keeps the original source in
// FlatAst form. Monomorphization and generic struct specialization are
// append-only, so the flat path stores just the per-file appended statements and
// lets the caller stream each original file through a one-file decode.
pub fn (mut t Transformer) prepare_flat_for_transform(flat &ast.FlatAst) map[int][]ast.Stmt {
    t.env.generic_types = map[string][]map[string]types.Type{}
    mut extra_stmts := map[int][]ast.Stmt{}
    t.collect_declared_method_fns_from_flat(flat)
    t.collect_struct_field_generic_decl_types_from_flat(flat)
    timing := os.getenv('V2_TTIME') != ''
    mut sw := time.new_stopwatch()
    mut prepared_dirty := true
    for iter in 0 .. 64 {
        spec_count := t.monomorphized_specs.len
        generic_count := t.generic_types_spec_count()
        struct_count := t.generic_struct_specs.len
        ts_start := sw.elapsed().milliseconds()
        if prepared_dirty {
            t.collect_generic_call_specs_from_flat(flat, extra_stmts)
        }
        ts_collect1 := sw.elapsed().milliseconds()
        before_mono := t.monomorphized_specs.len
        t.monomorphize_pass_from_flat(flat, mut extra_stmts)
        ts_mono := sw.elapsed().milliseconds()
        if t.monomorphized_specs.len != before_mono {
            t.collect_generic_call_specs_in_new_clones_from_flat(flat, extra_stmts)
        }
        ts_collect2 := sw.elapsed().milliseconds()
        t.inject_generic_struct_specializations_from_flat(flat, mut extra_stmts)
        ts_inject := sw.elapsed().milliseconds()
        if t.inject_changed_files {
            t.collect_generic_call_specs_in_new_structs_from_flat(flat, extra_stmts)
        }
        ts_collect3 := sw.elapsed().milliseconds()
        prepared_dirty = false
        if timing {
            eprintln('  [ttime] iter ${iter}: collect1=${ts_collect1 - ts_start}ms mono_pass=${ts_mono - ts_collect1}ms collect2=${ts_collect2 - ts_mono}ms inject=${ts_inject - ts_collect2}ms collect3=${ts_collect3 - ts_inject}ms files=${flat.files.len}')
        }
        t_print_mem('monomorphize iter ${iter}')
        if t.monomorphized_specs.len == spec_count && t.generic_types_spec_count() == generic_count
            && t.generic_struct_specs.len == struct_count {
            break
        }
    }
    if dump_path := os.getenv_opt('V2_TDUMP') {
        t.dump_flat_monomorphize_specs(dump_path, flat, extra_stmts)
    }
    t.collect_struct_default_decl_infos_from_flat(flat, extra_stmts)
    t.collect_concrete_embedded_owner_names_from_flat(flat, extra_stmts)
    return extra_stmts
}

// dump_monomorphize_specs writes a deterministic snapshot of the fixpoint's
// result (all monomorphized fn spec keys, generic struct spec keys, generic
// binding signatures, and per-file appended-stmt counts) to `path`. Used only
// for correctness validation: the file must be byte-identical before and after
// any optimization to the fixpoint loop. Gated on V2_TDUMP.
fn (t &Transformer) dump_monomorphize_specs(path string, prepared []ast.File) {
    mut lines := []string{}
    mut mspecs := t.monomorphized_specs.keys()
    mspecs.sort()
    lines << '# monomorphized_specs (${mspecs.len})'
    for k in mspecs {
        lines << 'M ${k}'
    }
    mut sspecs := t.generic_struct_specs.keys()
    sspecs.sort()
    lines << '# generic_struct_specs (${sspecs.len})'
    for k in sspecs {
        lines << 'S ${k}'
    }
    mut gkeys := t.env.generic_types.keys()
    gkeys.sort()
    lines << '# generic_types'
    for k in gkeys {
        blist := t.env.generic_types[k] or { continue }
        mut sigs := []string{}
        for b in blist {
            sigs << generic_bindings_signature(b)
        }
        sigs.sort()
        for sig in sigs {
            lines << 'G ${k} :: ${sig}'
        }
    }
    // Per-file fingerprint: file name + stmt count, in input order.
    lines << '# files (${prepared.len})'
    for f in prepared {
        lines << 'F ${f.mod}/${f.name} stmts=${f.stmts.len}'
    }
    os.write_file(path, lines.join('\n')) or {}
}

fn (t &Transformer) dump_flat_monomorphize_specs(path string, flat &ast.FlatAst, extra_stmts map[int][]ast.Stmt) {
    mut lines := []string{}
    mut mspecs := t.monomorphized_specs.keys()
    mspecs.sort()
    lines << '# monomorphized_specs (${mspecs.len})'
    for k in mspecs {
        lines << 'M ${k}'
    }
    mut sspecs := t.generic_struct_specs.keys()
    sspecs.sort()
    lines << '# generic_struct_specs (${sspecs.len})'
    for k in sspecs {
        lines << 'S ${k}'
    }
    mut gkeys := t.env.generic_types.keys()
    gkeys.sort()
    lines << '# generic_types'
    for k in gkeys {
        blist := t.env.generic_types[k] or { continue }
        mut sigs := []string{}
        for b in blist {
            sigs << generic_bindings_signature(b)
        }
        sigs.sort()
        for sig in sigs {
            lines << 'G ${k} :: ${sig}'
        }
    }
    lines << '# files (${flat.files.len})'
    for i, ff in flat.files {
        extra := extra_stmts[i] or { []ast.Stmt{} }
        stmt_count := flat_file_stmt_count(flat, i) + extra.len
        lines << 'F ${flat.file_mod(ff)}/${flat.file_name(ff)} stmts=${stmt_count}'
    }
    os.write_file(path, lines.join('\n')) or {}
}

fn flat_file_stmt_count(flat &ast.FlatAst, fi int) int {
    if fi < 0 || fi >= flat.files.len {
        return 0
    }
    return flat.file_cursor(fi).stmts().len()
}

fn (t &Transformer) generic_types_spec_count() int {
    mut count := 0
    for _, bindings_list in t.env.generic_types {
        count += bindings_list.len
    }
    return count
}

fn (mut t Transformer) collect_declared_method_fns(files []ast.File) {
    t.declared_method_fns = map[string]bool{}
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.is_method {
                t.register_declared_method_fn(stmt, file.mod)
            }
        }
    }
}

fn (mut t Transformer) collect_declared_method_fns_from_flat(flat &ast.FlatAst) {
    t.declared_method_fns = map[string]bool{}
    for fi in 0 .. flat.files.len {
        module_name := flat.file_mod(flat.files[fi])
        stmts := flat.file_cursor(fi).stmts()
        for si in 0 .. stmts.len() {
            c := stmts.at(si)
            if c.kind() != .stmt_fn_decl || !c.flag(ast.flag_is_method) {
                continue
            }
            t.register_declared_method_fn_cursor(c, module_name)
        }
    }
}

fn (mut t Transformer) register_declared_method_fn(decl ast.FnDecl, module_name string) {
    recv_name := t.get_receiver_type_name(decl.receiver.typ)
    if recv_name == '' || decl.name == '' {
        return
    }
    t.declared_method_fns['${recv_name}__${decl.name}'] = true
    if module_name != '' && module_name != 'builtin' && !recv_name.contains('__') {
        qualified := '${module_name.replace('.', '__')}__${recv_name}__${decl.name}'
        t.declared_method_fns[qualified] = true
        call_prefix := module_call_c_prefix(module_name)
        if call_prefix != '' && call_prefix != module_name.replace('.', '__') {
            t.declared_method_fns['${call_prefix}__${recv_name}__${decl.name}'] = true
        }
    }
}

fn (mut t Transformer) register_declared_method_fn_cursor(decl ast.Cursor, module_name string) {
    recv := decl.edge(0)
    recv_name := t.get_receiver_type_name_cursor(recv.edge(0))
    if recv_name == '' || decl.name() == '' {
        return
    }
    t.declared_method_fns['${recv_name}__${decl.name()}'] = true
    if module_name != '' && module_name != 'builtin' && !recv_name.contains('__') {
        qualified := '${module_name.replace('.', '__')}__${recv_name}__${decl.name()}'
        t.declared_method_fns[qualified] = true
        call_prefix := module_call_c_prefix(module_name)
        if call_prefix != '' && call_prefix != module_name.replace('.', '__') {
            t.declared_method_fns['${call_prefix}__${recv_name}__${decl.name()}'] = true
        }
    }
}

fn (mut t Transformer) collect_struct_field_generic_decl_types(files []ast.File) {
    old_module := t.cur_module
    old_scope := t.scope
    t.struct_field_generic_decl_types = map[string]types.Type{}
    t.struct_field_generic_decl_bindings = map[string]map[string]types.Type{}
    for file in files {
        t.cur_module = file.mod
        if scope := t.get_module_scope(file.mod) {
            t.scope = scope
        } else {
            t.scope = unsafe { nil }
        }
        for stmt in file.stmts {
            if stmt is ast.StructDecl {
                t.collect_struct_decl_generic_field_types(stmt, file.mod)
            }
        }
    }
    t.cur_module = old_module
    t.scope = old_scope
}

fn (mut t Transformer) collect_struct_field_generic_decl_types_from_flat(flat &ast.FlatAst) {
    old_module := t.cur_module
    old_scope := t.scope
    t.struct_field_generic_decl_types = map[string]types.Type{}
    t.struct_field_generic_decl_bindings = map[string]map[string]types.Type{}
    for fi in 0 .. flat.files.len {
        module_name := flat.file_mod(flat.files[fi])
        t.cur_module = module_name
        if scope := t.get_module_scope(module_name) {
            t.scope = scope
        } else {
            t.scope = unsafe { nil }
        }
        stmts := flat.file_cursor(fi).stmts()
        for si in 0 .. stmts.len() {
            c := stmts.at(si)
            if c.kind() != .stmt_struct_decl {
                continue
            }
            t.collect_struct_decl_generic_field_types_cursor(c, module_name)
        }
    }
    t.cur_module = old_module
    t.scope = old_scope
}

fn (mut t Transformer) collect_struct_decl_generic_field_types(decl ast.StructDecl, module_name string) {
    parent_names := struct_decl_field_lookup_names(decl.name, module_name)
    if parent_names.len == 0 {
        return
    }
    for field in decl.fields {
        if field.name == '' || !field_type_expr_has_generic_args(field.typ) {
            continue
        }
        field_type := t.lookup_type_from_expr(field.typ) or { continue }
        if !types.type_has_valid_payload(field_type) {
            continue
        }
        for parent_name in parent_names {
            t.struct_field_generic_decl_types[struct_field_generic_decl_key(parent_name, field.name)] = field_type
            if bindings := t.generic_bindings_from_type_expr(field.typ) {
                t.struct_field_generic_decl_bindings[struct_field_generic_decl_key(parent_name,
                    field.name)] = bindings.clone()
            }
        }
    }
    for embedded in decl.embedded {
        if !field_type_expr_has_generic_args(embedded) {
            continue
        }
        field_name := embedded_field_name_from_type_expr(embedded)
        if field_name == '' {
            continue
        }
        field_type := t.lookup_type_from_expr(embedded) or { continue }
        if !types.type_has_valid_payload(field_type) {
            continue
        }
        for parent_name in parent_names {
            t.struct_field_generic_decl_types[struct_field_generic_decl_key(parent_name, field_name)] = field_type
            if bindings := t.generic_bindings_from_type_expr(embedded) {
                t.struct_field_generic_decl_bindings[struct_field_generic_decl_key(parent_name,
                    field_name)] = bindings.clone()
            }
        }
    }
}

fn (mut t Transformer) collect_struct_decl_generic_field_types_cursor(decl ast.Cursor, module_name string) {
    parent_names := struct_decl_field_lookup_names(decl.name(), module_name)
    if parent_names.len == 0 {
        return
    }
    fields := decl.list_at(4)
    for i in 0 .. fields.len() {
        field := fields.at(i)
        field_name := field.name()
        if field_name == '' {
            continue
        }
        field_type_expr := field.edge(0)
        if !field_type_cursor_has_generic_args(field_type_expr) {
            continue
        }
        field_type := t.lookup_type_from_expr_cursor(field_type_expr) or { continue }
        if !types.type_has_valid_payload(field_type) {
            continue
        }
        for parent_name in parent_names {
            t.struct_field_generic_decl_types[struct_field_generic_decl_key(parent_name, field_name)] = field_type
            if bindings := t.generic_bindings_from_type_expr_cursor(field_type_expr) {
                t.struct_field_generic_decl_bindings[struct_field_generic_decl_key(parent_name,
                    field_name)] = bindings.clone()
            }
        }
    }
    embedded := decl.list_at(2)
    for i in 0 .. embedded.len() {
        embedded_expr := embedded.at(i)
        if !field_type_cursor_has_generic_args(embedded_expr) {
            continue
        }
        field_name := embedded_field_name_from_type_expr_cursor(embedded_expr)
        if field_name == '' {
            continue
        }
        field_type := t.lookup_type_from_expr_cursor(embedded_expr) or { continue }
        if !types.type_has_valid_payload(field_type) {
            continue
        }
        for parent_name in parent_names {
            t.struct_field_generic_decl_types[struct_field_generic_decl_key(parent_name, field_name)] = field_type
            if bindings := t.generic_bindings_from_type_expr_cursor(embedded_expr) {
                t.struct_field_generic_decl_bindings[struct_field_generic_decl_key(parent_name,
                    field_name)] = bindings.clone()
            }
        }
    }
}

fn (mut t Transformer) collect_concrete_embedded_owner_names(files []ast.File) {
    old_module := t.cur_module
    old_file := t.cur_file_name
    old_scope := t.scope
    old_import_aliases := t.cur_import_aliases.clone()
    t.concrete_embedded_owner_names = map[string]map[string]string{}
    for file in files {
        t.cur_file_name = file.name
        t.cur_module = file.mod
        t.cur_import_aliases = import_aliases_for_generic_collect(file.imports)
        if scope := t.get_module_scope(file.mod) {
            t.scope = scope
        } else {
            t.scope = unsafe { nil }
        }
        for stmt in file.stmts {
            if stmt is ast.StructDecl {
                mut embedded := []ast.Expr{cap: stmt.embedded.len}
                for item in stmt.embedded {
                    embedded << t.rewrite_concrete_generic_struct_type_expr(item)
                }
                t.register_concrete_embedded_owner_names(stmt, embedded)
            }
        }
    }
    t.cur_module = old_module
    t.cur_file_name = old_file
    t.scope = old_scope
    t.cur_import_aliases = old_import_aliases.clone()
}

fn (mut t Transformer) collect_concrete_embedded_owner_names_from_flat(flat &ast.FlatAst, extra_stmts map[int][]ast.Stmt) {
    old_module := t.cur_module
    old_file := t.cur_file_name
    old_scope := t.scope
    old_import_aliases := t.cur_import_aliases.clone()
    t.concrete_embedded_owner_names = map[string]map[string]string{}
    for fi in 0 .. flat.files.len {
        module_name := flat.file_mod(flat.files[fi])
        t.cur_file_name = flat.file_name(flat.files[fi])
        t.cur_module = module_name
        t.cur_import_aliases = flat_import_aliases_for_generic_collect(flat, fi)
        if scope := t.get_module_scope(module_name) {
            t.scope = scope
        } else {
            t.scope = unsafe { nil }
        }
        for stmt in flat_file_struct_decls_with_extra(flat, extra_stmts, fi) {
            mut embedded := []ast.Expr{cap: stmt.embedded.len}
            for item in stmt.embedded {
                embedded << t.rewrite_concrete_generic_struct_type_expr(item)
            }
            t.register_concrete_embedded_owner_names(stmt, embedded)
        }
    }
    t.cur_module = old_module
    t.cur_file_name = old_file
    t.scope = old_scope
    t.cur_import_aliases = old_import_aliases.clone()
}

fn (mut t Transformer) collect_struct_default_decl_infos(files []ast.File) {
    t.struct_default_decl_infos = map[string]StructDefaultDeclInfo{}
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.StructDecl {
                info := StructDefaultDeclInfo{
                    decl:        stmt
                    module_name: file.mod
                }
                c_name := generic_struct_decl_c_name(stmt, file.mod)
                t.struct_default_decl_infos[c_name] = info
                if c_name.contains('__') {
                    t.struct_default_decl_infos[c_name.all_after_last('__')] = info
                }
                t.struct_default_decl_infos[stmt.name] = info
            }
        }
    }
}

fn (mut t Transformer) collect_struct_default_decl_infos_from_flat(flat &ast.FlatAst, extra_stmts map[int][]ast.Stmt) {
    t.struct_default_decl_infos = map[string]StructDefaultDeclInfo{}
    for fi in 0 .. flat.files.len {
        module_name := flat.file_mod(flat.files[fi])
        for stmt in flat_file_struct_decls_with_extra(flat, extra_stmts, fi) {
            info := StructDefaultDeclInfo{
                decl:        stmt
                module_name: module_name
            }
            c_name := generic_struct_decl_c_name(stmt, module_name)
            t.struct_default_decl_infos[c_name] = info
            if c_name.contains('__') {
                t.struct_default_decl_infos[c_name.all_after_last('__')] = info
            }
            t.struct_default_decl_infos[stmt.name] = info
        }
    }
}

fn generic_struct_runtime_args(args []ast.Expr) []ast.Expr {
    mut out := []ast.Expr{cap: args.len}
    for arg in args {
        if arg is ast.LifetimeExpr {
            continue
        }
        out << arg
    }
    return out
}

fn generic_struct_module_from_c_name(c_name string, fallback string) string {
    if c_name.contains('__') {
        return c_name.all_before_last('__')
    }
    return fallback
}

fn generic_struct_short_name_from_c_name(c_name string) string {
    if c_name.contains('__') {
        return c_name.all_after_last('__')
    }
    return c_name
}

fn generic_struct_decl_c_name(decl ast.StructDecl, module_name string) string {
    name := decl.name.replace('.', '__')
    if module_name != '' && module_name != 'main' && module_name != 'builtin'
        && !name.contains('__') {
        return '${module_name.replace('.', '__')}__${name}'
    }
    return name
}

fn (mut t Transformer) collect_generic_struct_spec_from_type_expr(expr ast.Expr) {
    mut lhs := ast.empty_expr
    mut args := []ast.Expr{}
    match expr {
        ast.GenericArgs {
            lhs = expr.lhs
            args = expr.args.clone()
        }
        ast.GenericArgOrIndexExpr {
            lhs = expr.lhs
            args = [expr.expr]
        }
        ast.IndexExpr {
            lhs = expr.lhs
            args = [expr.expr]
        }
        ast.Type {
            if expr is ast.GenericType {
                lhs = expr.name
                args = expr.params.clone()
            } else {
                return
            }
        }
        ast.ModifierExpr {
            t.collect_generic_struct_spec_from_type_expr(expr.expr)
            return
        }
        ast.PrefixExpr {
            t.collect_generic_struct_spec_from_type_expr(expr.expr)
            return
        }
        else {
            return
        }
    }

    t.register_generic_struct_spec(lhs, args)
}

fn (mut t Transformer) collect_generic_struct_spec_from_type_expr_cursor(expr ast.Cursor) {
    if !expr.is_valid() {
        return
    }
    mut lhs := ast.Cursor{}
    mut args := []ast.Cursor{}
    match expr.kind() {
        .expr_generic_args {
            lhs = expr.edge(0)
            for i in 1 .. expr.edge_count() {
                args << expr.edge(i)
            }
        }
        .expr_generic_arg_or_index, .expr_index {
            lhs = expr.edge(0)
            args = [expr.edge(1)]
        }
        .typ_generic {
            lhs = expr.edge(0)
            for i in 1 .. expr.edge_count() {
                args << expr.edge(i)
            }
        }
        .expr_modifier, .expr_prefix {
            t.collect_generic_struct_spec_from_type_expr_cursor(expr.edge(0))
            return
        }
        else {
            return
        }
    }

    t.register_generic_struct_spec_cursor(lhs, args)
}

fn (mut t Transformer) register_generic_struct_spec(lhs ast.Expr, args []ast.Expr) {
    runtime_args := generic_struct_runtime_args(args)
    if runtime_args.len == 0 {
        return
    }
    base_type := t.lookup_type_from_expr(lhs) or { return }
    if base_type !is types.Struct {
        return
    }
    base_struct := base_type as types.Struct
    if base_struct.generic_params.len == 0 {
        return
    }
    bindings := t.generic_type_arg_bindings(base_struct.generic_params, runtime_args) or { return }
    if bindings.len != base_struct.generic_params.len {
        return
    }
    for _, concrete in bindings {
        if clone_type_contains_generic_placeholder(concrete) {
            return
        }
    }
    base_c_name := t.type_to_c_name(types.Type(base_struct))
    suffix := t.generic_specialization_suffix(runtime_args)
    if base_c_name == '' || suffix == '' || !suffix.starts_with('_T_') {
        return
    }
    concrete_c_name := base_c_name + suffix
    if concrete_c_name in t.generic_struct_specs {
        return
    }
    module_name := generic_struct_module_from_c_name(base_c_name, t.cur_module)
    file_idx := if t.generic_bindings_visible_in_module(module_name, bindings) {
        -1
    } else {
        t.cur_generic_call_file_idx
    }
    spec := GenericStructSpec{
        base_c_name:         base_c_name
        concrete_c_name:     concrete_c_name
        concrete_short_name: generic_struct_short_name_from_c_name(concrete_c_name)
        module_name:         module_name
        file_idx:            file_idx
        bindings:            bindings.clone()
    }
    t.generic_struct_specs[concrete_c_name] = spec
    t.register_generic_struct_env_type(base_struct, spec)
}

fn (mut t Transformer) register_generic_struct_spec_cursor(lhs ast.Cursor, args []ast.Cursor) {
    runtime_args := generic_struct_runtime_arg_cursors(args)
    if runtime_args.len == 0 {
        return
    }
    base_type := t.lookup_type_from_expr_cursor(lhs) or { return }
    if base_type !is types.Struct {
        return
    }
    base_struct := base_type as types.Struct
    if base_struct.generic_params.len == 0 {
        return
    }
    arg_bindings := t.generic_type_arg_bindings_cursor(base_struct.generic_params, runtime_args) or {
        return
    }
    bindings := arg_bindings.bindings.clone()
    if bindings.len != base_struct.generic_params.len {
        return
    }
    for _, concrete in bindings {
        if clone_type_contains_generic_placeholder(concrete) {
            return
        }
    }
    base_c_name := t.type_to_c_name(types.Type(base_struct))
    suffix := t.generic_specialization_suffix_from_types(arg_bindings.concrete_args)
    if base_c_name == '' || suffix == '' || !suffix.starts_with('_T_') {
        return
    }
    concrete_c_name := base_c_name + suffix
    if concrete_c_name in t.generic_struct_specs {
        return
    }
    module_name := generic_struct_module_from_c_name(base_c_name, t.cur_module)
    file_idx := if t.generic_bindings_visible_in_module(module_name, bindings) {
        -1
    } else {
        t.cur_generic_call_file_idx
    }
    spec := GenericStructSpec{
        base_c_name:         base_c_name
        concrete_c_name:     concrete_c_name
        concrete_short_name: generic_struct_short_name_from_c_name(concrete_c_name)
        module_name:         module_name
        file_idx:            file_idx
        bindings:            bindings.clone()
    }
    t.generic_struct_specs[concrete_c_name] = spec
    t.register_generic_struct_env_type(base_struct, spec)
}

fn generic_struct_runtime_arg_cursors(args []ast.Cursor) []ast.Cursor {
    mut out := []ast.Cursor{cap: args.len}
    for arg in args {
        if arg.kind() == .expr_lifetime {
            continue
        }
        out << arg
    }
    return out
}

fn (t &Transformer) generic_type_arg_bindings_cursor(generic_params []string, args []ast.Cursor) ?GenericTypeArgCursorBindings {
    if generic_params.len == 0 || args.len == 0 {
        return none
    }
    mut bindings := map[string]types.Type{}
    mut concrete_args := []types.Type{cap: args.len}
    for i, param_name in generic_params {
        if i >= args.len {
            break
        }
        arg := args[i]
        mut found := false
        mut concrete := types.Type(types.void_)
        if arg.kind() == .expr_ident {
            if bound_type := t.cur_monomorphized_fn_bindings[arg.name()] {
                concrete = t.qualify_generic_concrete_type_from_cursor(bound_type, arg)
                found = true
            }
        }
        if !found {
            if synth_type := t.get_synth_type(arg.pos()) {
                concrete = t.qualify_generic_concrete_type_from_cursor(synth_type, arg)
                found = true
            }
        }
        if !found {
            if typ := t.lookup_type_from_expr_cursor(arg) {
                concrete = t.qualify_generic_concrete_type_from_cursor(typ, arg)
                found = true
            }
        }
        if !found {
            if typ := t.get_expr_type_cursor(arg) {
                concrete = t.qualify_generic_concrete_type_from_cursor(typ, arg)
                found = true
            }
        }
        if found {
            bindings[param_name] = concrete
            concrete_args << concrete
        }
    }
    if bindings.len == 0 {
        return none
    }
    return GenericTypeArgCursorBindings{
        bindings:      bindings
        concrete_args: concrete_args
    }
}

fn (t &Transformer) generic_specialization_suffix_from_types(args []types.Type) string {
    if args.len == 0 {
        return ''
    }
    mut parts := []string{cap: args.len}
    for arg in args {
        parts << t.generic_specialization_token_from_type(arg)
    }
    return '_T_' + parts.join('_')
}

fn (t &Transformer) lookup_type_from_expr_cursor(expr ast.Cursor) ?types.Type {
    if !expr.is_valid() || expr.kind() == .expr_empty {
        return none
    }
    if typ := t.get_synth_type(expr.pos()) {
        return typ
    }
    match expr.kind() {
        .expr_ident {
            name := expr.name()
            if typ := t.lookup_type(name) {
                return typ
            }
            if typ := t.c_name_to_type(name) {
                return typ
            }
            c_name := t.v_type_name_to_c_name(name)
            if c_name != '' && c_name != name {
                if typ := t.c_name_to_type(c_name) {
                    return typ
                }
            }
        }
        .expr_selector {
            lhs := expr.edge(0)
            rhs_name := selector_rhs_name_cursor(expr)
            if lhs.kind() == .expr_ident && rhs_name != '' {
                lhs_name := lhs.name()
                mut module_names := []string{}
                if full_name := t.cur_import_aliases[lhs_name] {
                    module_names << module_call_c_prefix(full_name)
                    module_names << full_name.replace('.', '__')
                }
                if prefix := t.resolve_module_call_prefix(lhs_name) {
                    module_names << prefix
                }
                module_names << lhs_name.replace('.', '__')
                mut seen := map[string]bool{}
                for module_name in module_names {
                    if module_name == '' || module_name in seen {
                        continue
                    }
                    seen[module_name] = true
                    qualified := '${module_name}__${rhs_name}'
                    if typ := t.lookup_type(qualified) {
                        return typ
                    }
                }
                return t.lookup_type(rhs_name)
            }
        }
        .expr_prefix {
            op := unsafe { token.Token(int(expr.aux())) }
            if op == .amp {
                base := t.lookup_type_from_expr_cursor(expr.edge(0)) or { return none }
                return types.Type(types.Pointer{
                    base_type: base
                })
            }
        }
        .expr_modifier {
            return t.lookup_type_from_expr_cursor(expr.edge(0))
        }
        .expr_generic_args {
            return t.lookup_generic_type_from_expr_cursor(expr.edge(0), cursor_edges(expr, 1))
        }
        .expr_generic_arg_or_index, .expr_index {
            return t.lookup_generic_type_from_expr_cursor(expr.edge(0), [
                expr.edge(1),
            ])
        }
        .typ_pointer {
            base := t.lookup_type_from_expr_cursor(expr.edge(0)) or { return none }
            return types.Type(types.Pointer{
                base_type: base
            })
        }
        .typ_option {
            base := t.lookup_type_from_expr_cursor(expr.edge(0)) or { return none }
            return types.Type(types.OptionType{
                base_type: base
            })
        }
        .typ_result {
            base := t.lookup_type_from_expr_cursor(expr.edge(0)) or { return none }
            return types.Type(types.ResultType{
                base_type: base
            })
        }
        .typ_map {
            key := t.lookup_type_from_expr_cursor(expr.edge(0)) or { return none }
            value := t.lookup_type_from_expr_cursor(expr.edge(1)) or { return none }
            return types.Type(types.Map{
                key_type:   key
                value_type: value
            })
        }
        .typ_array {
            elem := t.lookup_type_from_expr_cursor(expr.edge(0)) or { return none }
            return types.Type(types.Array{
                elem_type: elem
            })
        }
        .typ_array_fixed {
            len_expr := expr.edge(0)
            mut len := 0
            if len_expr.kind() == .expr_basic_literal {
                len = len_expr.name().int()
            }
            elem := t.lookup_type_from_expr_cursor(expr.edge(1)) or { return none }
            return types.Type(types.ArrayFixed{
                len:       len
                elem_type: elem
            })
        }
        .typ_generic {
            return t.lookup_generic_type_from_expr_cursor(expr.edge(0), cursor_edges(expr, 1))
        }
        else {}
    }

    return none
}

fn cursor_edges(expr ast.Cursor, start int) []ast.Cursor {
    mut out := []ast.Cursor{cap: expr.edge_count() - start}
    for i in start .. expr.edge_count() {
        out << expr.edge(i)
    }
    return out
}

fn (t &Transformer) lookup_generic_type_from_expr_cursor(lhs ast.Cursor, args []ast.Cursor) ?types.Type {
    base := t.lookup_type_from_expr_cursor(lhs) or { return none }
    if base is types.Struct {
        arg_bindings := t.generic_type_arg_bindings_cursor(base.generic_params, args) or {
            return base
        }
        return substitute_type(base, arg_bindings.bindings)
    }
    return base
}

fn (t &Transformer) qualify_generic_concrete_type_from_cursor(concrete types.Type, arg ast.Cursor) types.Type {
    match concrete {
        types.Struct {
            if name := t.generic_concrete_type_arg_c_name_cursor(types.Type(concrete), arg) {
                return types.Type(types.Struct{
                    name:           name
                    generic_params: concrete.generic_params
                    implements:     concrete.implements
                    embedded:       concrete.embedded
                    fields:         concrete.fields
                    is_soa:         concrete.is_soa
                })
            }
        }
        types.Enum {
            if name := t.generic_concrete_type_arg_c_name_cursor(types.Type(concrete), arg) {
                return types.Type(types.Enum{
                    is_flag: concrete.is_flag
                    name:    name
                    fields:  concrete.fields
                })
            }
        }
        types.Interface {
            if name := t.generic_concrete_type_arg_c_name_cursor(types.Type(concrete), arg) {
                return types.Type(types.Interface{
                    name:   name
                    fields: concrete.fields
                })
            }
        }
        types.SumType {
            if name := t.generic_concrete_type_arg_c_name_cursor(types.Type(concrete), arg) {
                return types.Type(types.SumType{
                    name:           name
                    generic_params: concrete.generic_params
                    variants:       concrete.variants
                })
            }
        }
        types.Alias {
            if name := t.generic_concrete_type_arg_c_name_cursor(types.Type(concrete), arg) {
                return types.Type(types.Alias{
                    name:      name
                    base_type: concrete.base_type
                })
            }
        }
        types.NamedType {
            if name := t.generic_concrete_type_arg_c_name_cursor(types.Type(concrete), arg) {
                return types.Type(types.NamedType(name))
            }
        }
        types.Pointer {
            if base_arg := pointer_generic_type_arg_base_cursor(arg) {
                return types.Type(types.Pointer{
                    lifetime:  concrete.lifetime
                    base_type: t.qualify_generic_concrete_type_from_cursor(concrete.base_type,
                        base_arg)
                })
            }
        }
        types.Array {
            if elem_arg := array_generic_type_arg_elem_cursor(arg) {
                return types.Type(types.Array{
                    elem_type: t.qualify_generic_concrete_type_from_cursor(concrete.elem_type,
                        elem_arg)
                })
            }
        }
        types.ArrayFixed {
            if elem_arg := array_fixed_generic_type_arg_elem_cursor(arg) {
                return types.Type(types.ArrayFixed{
                    len:       concrete.len
                    elem_type: t.qualify_generic_concrete_type_from_cursor(concrete.elem_type,
                        elem_arg)
                })
            }
        }
        types.Map {
            if parts := map_generic_type_arg_parts_cursor(arg) {
                return types.Type(types.Map{
                    key_type:   t.qualify_generic_concrete_type_from_cursor(concrete.key_type,
                        parts.key)
                    value_type: t.qualify_generic_concrete_type_from_cursor(concrete.value_type,
                        parts.value)
                })
            }
        }
        types.OptionType {
            if base_arg := option_generic_type_arg_base_cursor(arg) {
                return types.Type(types.OptionType{
                    base_type: t.qualify_generic_concrete_type_from_cursor(concrete.base_type,
                        base_arg)
                })
            }
        }
        types.ResultType {
            if base_arg := result_generic_type_arg_base_cursor(arg) {
                return types.Type(types.ResultType{
                    base_type: t.qualify_generic_concrete_type_from_cursor(concrete.base_type,
                        base_arg)
                })
            }
        }
        else {}
    }

    return concrete
}

fn (t &Transformer) generic_concrete_type_arg_c_name_cursor(concrete types.Type, arg ast.Cursor) ?string {
    if arg.kind() == .expr_ident {
        name := arg.name()
        if bound_type := t.cur_monomorphized_fn_bindings[name] {
            c_name := t.type_to_c_name(bound_type)
            if c_name != '' {
                return c_name
            }
        }
        if name.contains('__') {
            return name
        }
        if concrete.name() == name {
            return t.generic_ident_type_arg_c_name(name)
        }
    }
    if arg.kind() == .typ_generic {
        base_name := t.expr_to_type_name_cursor_direct(arg.edge(0))
        suffix := t.generic_specialization_suffix_from_type_cursors(cursor_edges(arg, 1))
        if base_name != '' && suffix != '' {
            return base_name + suffix
        }
    }
    if name := t.generic_init_type_name_cursor_direct(arg) {
        return name
    }
    name := t.expr_to_type_name_cursor_direct(arg)
    if name == '' {
        return none
    }
    return name
}

fn (t &Transformer) generic_specialization_suffix_from_type_cursors(args []ast.Cursor) string {
    runtime_args := generic_struct_runtime_arg_cursors(args)
    if runtime_args.len == 0 {
        return ''
    }
    arg_bindings := t.generic_type_arg_bindings_cursor(runtime_arg_names(runtime_args),
        runtime_args) or { return '' }
    if arg_bindings.concrete_args.len != runtime_args.len {
        return ''
    }
    for concrete in arg_bindings.concrete_args {
        if clone_type_contains_generic_placeholder(concrete) {
            return ''
        }
    }
    return t.generic_specialization_suffix_from_types(arg_bindings.concrete_args)
}

fn runtime_arg_names(args []ast.Cursor) []string {
    mut names := []string{cap: args.len}
    for i in 0 .. args.len {
        names << 'T${i}'
    }
    return names
}

fn (t &Transformer) generic_init_type_name_cursor_direct(expr ast.Cursor) ?string {
    match expr.kind() {
        .expr_generic_args {
            base_name := t.expr_to_type_name_cursor_direct(expr.edge(0))
            suffix := t.generic_specialization_suffix_from_type_cursors(cursor_edges(expr, 1))
            if base_name != '' && suffix != '' {
                return base_name + suffix
            }
        }
        .expr_generic_arg_or_index, .expr_index {
            base_name := t.expr_to_type_name_cursor_direct(expr.edge(0))
            suffix := t.generic_specialization_suffix_from_type_cursors([
                expr.edge(1),
            ])
            if base_name != '' && suffix != '' {
                return base_name + suffix
            }
        }
        else {}
    }

    return none
}

fn (t &Transformer) expr_to_type_name_cursor_direct(expr ast.Cursor) string {
    match expr.kind() {
        .expr_ident {
            if typ := t.get_synth_type(expr.pos()) {
                c_name := t.type_to_c_name(typ)
                if c_name != '' {
                    return c_name
                }
            }
            return expr.name()
        }
        .expr_selector {
            return selector_type_name_cursor(expr, true)
        }
        .typ_array, .typ_array_fixed, .typ_map, .typ_option, .typ_pointer, .typ_result,
        .typ_generic {
            if typ := t.lookup_type_from_expr_cursor(expr) {
                c_name := t.type_to_c_name(typ)
                if c_name != '' {
                    return c_name
                }
            }
        }
        else {}
    }

    return ''
}

fn pointer_generic_type_arg_base_cursor(arg ast.Cursor) ?ast.Cursor {
    match arg.kind() {
        .expr_prefix {
            op := unsafe { token.Token(int(arg.aux())) }
            if op in [.amp, .mul] {
                return arg.edge(0)
            }
        }
        .typ_pointer {
            return arg.edge(0)
        }
        else {}
    }

    return none
}

fn array_generic_type_arg_elem_cursor(arg ast.Cursor) ?ast.Cursor {
    if arg.kind() == .typ_array {
        return arg.edge(0)
    }
    return none
}

fn array_fixed_generic_type_arg_elem_cursor(arg ast.Cursor) ?ast.Cursor {
    if arg.kind() == .typ_array_fixed {
        return arg.edge(1)
    }
    return none
}

struct GenericMapTypeArgCursorParts {
    key   ast.Cursor
    value ast.Cursor
}

fn map_generic_type_arg_parts_cursor(arg ast.Cursor) ?GenericMapTypeArgCursorParts {
    if arg.kind() == .typ_map {
        return GenericMapTypeArgCursorParts{
            key:   arg.edge(0)
            value: arg.edge(1)
        }
    }
    return none
}

fn option_generic_type_arg_base_cursor(arg ast.Cursor) ?ast.Cursor {
    if arg.kind() == .typ_option {
        return arg.edge(0)
    }
    return none
}

fn result_generic_type_arg_base_cursor(arg ast.Cursor) ?ast.Cursor {
    if arg.kind() == .typ_result {
        return arg.edge(0)
    }
    return none
}

fn (t &Transformer) generic_bindings_visible_in_module(module_name string, bindings map[string]types.Type) bool {
    for _, typ in bindings {
        if !t.generic_type_visible_in_module(module_name, typ) {
            return false
        }
    }
    return true
}

fn (t &Transformer) generic_type_visible_in_module(module_name string, typ types.Type) bool {
    match typ {
        types.Primitive, types.String, types.Char, types.Rune, types.Void, types.Nil, types.None,
        types.ISize, types.USize {
            return true
        }
        types.Struct {
            return t.generic_type_name_visible_in_module(module_name, typ.name)
        }
        types.Enum {
            return t.generic_type_name_visible_in_module(module_name, typ.name)
        }
        types.Interface {
            return t.generic_type_name_visible_in_module(module_name, typ.name)
        }
        types.SumType {
            return t.generic_type_name_visible_in_module(module_name, types.sum_type_name(typ))
        }
        types.Alias {
            return t.generic_type_name_visible_in_module(module_name, typ.name)
        }
        types.NamedType {
            return t.generic_type_name_visible_in_module(module_name, string(typ))
        }
        types.Pointer {
            return t.generic_type_visible_in_module(module_name, typ.base_type)
        }
        types.Array {
            return t.generic_type_visible_in_module(module_name, typ.elem_type)
        }
        types.ArrayFixed {
            return t.generic_type_visible_in_module(module_name, typ.elem_type)
        }
        types.Map {
            return t.generic_type_visible_in_module(module_name, typ.key_type)
                && t.generic_type_visible_in_module(module_name, typ.value_type)
        }
        types.OptionType {
            return t.generic_type_visible_in_module(module_name, typ.base_type)
        }
        types.ResultType {
            return t.generic_type_visible_in_module(module_name, typ.base_type)
        }
        types.FnType {
            for param_type in typ.get_param_types() {
                if !t.generic_type_visible_in_module(module_name, param_type) {
                    return false
                }
            }
            if ret_type := typ.get_return_type() {
                return t.generic_type_visible_in_module(module_name, ret_type)
            }
            return true
        }
        else {
            return true
        }
    }
}

fn (t &Transformer) generic_type_name_visible_in_module(module_name string, type_name string) bool {
    if type_name == '' || t.is_builtin_type_name(type_name) {
        return true
    }
    name := type_name.replace('.', '__')
    if name.contains('__') {
        mod_prefix := module_name.replace('.', '__')
        return name.starts_with('${mod_prefix}__')
    }
    if module_name == '' || module_name == 'main' {
        return true
    }
    if scope := t.get_module_scope(module_name) {
        if obj := scope.objects[name] {
            if _ := transformer_object_type(obj) {
                return true
            }
        }
    }
    return false
}

fn (mut t Transformer) register_generic_struct_env_type(base_struct types.Struct, spec GenericStructSpec) {
    substituted := substitute_type(types.Type(base_struct), spec.bindings)
    mut struct_info := if substituted is types.Struct {
        substituted as types.Struct
    } else {
        base_struct
    }
    concrete_type := types.Type(types.Struct{
        name:           spec.concrete_c_name
        generic_params: []string{}
        implements:     struct_info.implements
        embedded:       struct_info.embedded
        fields:         struct_info.fields
        is_soa:         struct_info.is_soa
    })
    if mut scope := t.get_module_scope(spec.module_name) {
        scope.insert_type(spec.concrete_short_name, concrete_type)
        scope.objects[spec.concrete_short_name] = types.TypeObject{
            typ: concrete_type
        }
    }
}

fn (t &Transformer) generic_struct_spec_key_from_type_expr(expr ast.Expr) ?string {
    mut lhs := ast.empty_expr
    mut args := []ast.Expr{}
    match expr {
        ast.GenericArgs {
            lhs = expr.lhs
            args = expr.args.clone()
        }
        ast.GenericArgOrIndexExpr {
            lhs = expr.lhs
            args = [expr.expr]
        }
        ast.IndexExpr {
            lhs = expr.lhs
            args = [expr.expr]
        }
        ast.Type {
            if expr is ast.GenericType {
                lhs = expr.name
                args = expr.params.clone()
            } else {
                return none
            }
        }
        ast.ModifierExpr {
            return t.generic_struct_spec_key_from_type_expr(expr.expr)
        }
        ast.PrefixExpr {
            return t.generic_struct_spec_key_from_type_expr(expr.expr)
        }
        else {
            return none
        }
    }

    base_type := t.lookup_type_from_expr(lhs) or { return none }
    if base_type !is types.Struct {
        return none
    }
    base_struct := base_type as types.Struct
    if base_struct.generic_params.len == 0 {
        return none
    }
    runtime_args := generic_struct_runtime_args(args)
    if runtime_args.len == 0 {
        return none
    }
    base_c_name := t.type_to_c_name(types.Type(base_struct))
    suffix := t.generic_specialization_suffix(runtime_args)
    if base_c_name == '' || suffix == '' {
        return none
    }
    return base_c_name + suffix
}

fn (t &Transformer) generic_struct_spec_from_type_expr(expr ast.Expr) ?GenericStructSpec {
    key := t.generic_struct_spec_key_from_type_expr(expr) or { return none }
    return t.generic_struct_specs[key] or { return none }
}

fn (mut t Transformer) concrete_generic_struct_type_expr(expr ast.Expr) ?ast.Expr {
    spec := t.generic_struct_spec_from_type_expr(expr) or { return none }
    mut pos := expr.pos()
    if !pos.is_valid() {
        pos = t.next_synth_pos()
    }
    concrete_type := types.Type(types.Struct{
        name: spec.concrete_c_name
    })
    t.register_synth_type(pos, concrete_type)
    return ast.Expr(ast.Ident{
        name: spec.concrete_c_name
        pos:  pos
    })
}

fn (mut t Transformer) clone_generic_struct_decl(decl ast.StructDecl, spec GenericStructSpec, target_module string) ast.StructDecl {
    old_module := t.cur_module
    old_scope := t.scope
    t.cur_module = spec.module_name
    if scope := t.get_module_scope(spec.module_name) {
        t.scope = scope
    }
    should_qualify_source_types := target_module != spec.module_name && spec.module_name != ''
        && spec.module_name != 'main' && spec.module_name != 'builtin'
    mut fields := []ast.FieldDecl{cap: decl.fields.len}
    for field in decl.fields {
        mut field_typ := t.substitute_type_in_expr(field.typ, spec.bindings)
        mut field_value := t.clone_expr_with_bindings(field.value, spec.bindings)
        if should_qualify_source_types {
            field_typ = t.qualify_moved_clone_type_expr(field_typ, spec.module_name)
            field_value = t.qualify_moved_clone_expr_type_positions(field_value, spec.module_name)
        }
        fields << ast.FieldDecl{
            name:                field.name
            typ:                 field_typ
            value:               field_value
            attributes:          field.attributes
            is_public:           field.is_public
            is_mut:              field.is_mut
            is_module_mut:       field.is_module_mut
            is_interface_method: field.is_interface_method
        }
    }
    mut embedded := []ast.Expr{cap: decl.embedded.len}
    for item in decl.embedded {
        mut embedded_type := t.substitute_type_in_expr(item, spec.bindings)
        if should_qualify_source_types {
            embedded_type = t.qualify_moved_clone_type_expr(embedded_type, spec.module_name)
        }
        embedded << embedded_type
    }
    mut implemented_types := []ast.Expr{cap: decl.implements.len}
    for item in decl.implements {
        mut implemented_type := t.substitute_type_in_expr(item, spec.bindings)
        if should_qualify_source_types {
            implemented_type = t.qualify_moved_clone_type_expr(implemented_type, spec.module_name)
        }
        implemented_types << implemented_type
    }
    cloned := ast.StructDecl{
        attributes:     decl.attributes
        is_public:      decl.is_public
        is_union:       decl.is_union
        implements:     implemented_types
        embedded:       embedded
        language:       decl.language
        name:           if target_module == spec.module_name {
            spec.concrete_short_name
        } else {
            spec.concrete_c_name
        }
        generic_params: []ast.Expr{}
        fields:         fields
        pos:            decl.pos
    }
    t.cur_module = old_module
    t.scope = old_scope
    return cloned
}

fn (mut t Transformer) inject_generic_struct_specializations(files []ast.File) []ast.File {
    t.inject_changed_files = false
    t.last_struct_clones = map[int][]ast.Stmt{}
    if t.generic_struct_specs.len == 0 {
        return files
    }
    mut existing := map[string]bool{}
    mut base_decls := map[string]ast.StructDecl{}
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.StructDecl {
                c_name := generic_struct_decl_c_name(stmt, file.mod)
                existing[c_name] = true
                if stmt.generic_params.len > 0 {
                    base_decls[c_name] = stmt
                }
            }
        }
    }
    spec_keys := t.generic_struct_specs.keys()
    mut sorted_keys := spec_keys.clone()
    sorted_keys.sort()
    // Fast path: if every struct spec is already present in `files`, nothing
    // will be injected and the loop below would only rebuild an identical file
    // set. Return the input unchanged to avoid duplicating every file's stmt
    // list (~1.5GB under -gc none on the fixpoint loop's confirmation pass).
    // Mirrors monomorphize_pass's `per_file_clones.len == 0 { return files }`.
    mut any_pending := false
    for key in sorted_keys {
        spec := t.generic_struct_specs[key] or { continue }
        if spec.concrete_c_name !in existing {
            any_pending = true
            break
        }
    }
    if !any_pending {
        return files
    }
    mut out := []ast.File{cap: files.len}
    for file in files {
        mut stmts := []ast.Stmt{cap: file.stmts.len}
        for stmt in file.stmts {
            stmts << stmt
        }
        mut injected := []ast.Stmt{}
        for key in sorted_keys {
            spec := t.generic_struct_specs[key] or { continue }
            if spec.file_idx < 0 || spec.file_idx >= files.len || spec.file_idx != out.len
                || spec.concrete_c_name in existing {
                continue
            }
            struct_decl := base_decls[spec.base_c_name] or { continue }
            cloned := ast.Stmt(t.clone_generic_struct_decl(struct_decl, spec, file.mod))
            stmts << cloned
            injected << cloned
            existing[spec.concrete_c_name] = true
        }
        for key in sorted_keys {
            spec := t.generic_struct_specs[key] or { continue }
            if (spec.file_idx >= 0 && spec.file_idx < files.len)
                || spec.module_name != file.mod || spec.concrete_c_name in existing {
                continue
            }
            struct_decl := base_decls[spec.base_c_name] or { continue }
            cloned := ast.Stmt(t.clone_generic_struct_decl(struct_decl, spec, file.mod))
            stmts << cloned
            injected << cloned
            existing[spec.concrete_c_name] = true
        }
        if injected.len > 0 {
            t.last_struct_clones[out.len] = injected
        }
        out << ast.File{
            attributes:     file.attributes
            mod:            file.mod
            name:           file.name
            stmts:          stmts
            imports:        file.imports
            selector_names: file.selector_names
        }
    }
    t.inject_changed_files = true
    return out
}

fn (t &Transformer) generic_bindings_from_type_expr(expr ast.Expr) ?map[string]types.Type {
    match expr {
        ast.GenericArgs {
            return t.generic_bindings_from_generic_type_parts(expr.lhs, expr.args)
        }
        ast.GenericArgOrIndexExpr {
            return t.generic_bindings_from_generic_type_parts(expr.lhs, [expr.expr])
        }
        ast.ModifierExpr {
            return t.generic_bindings_from_type_expr(expr.expr)
        }
        ast.PrefixExpr {
            return t.generic_bindings_from_type_expr(expr.expr)
        }
        ast.Type {
            match expr {
                ast.GenericType {
                    return t.generic_bindings_from_generic_type_parts(expr.name, expr.params)
                }
                ast.PointerType {
                    return t.generic_bindings_from_type_expr(expr.base_type)
                }
                else {}
            }
        }
        else {}
    }

    return none
}

fn (t &Transformer) generic_bindings_from_generic_type_parts(lhs ast.Expr, args []ast.Expr) ?map[string]types.Type {
    generic_params := t.generic_template_type_param_names_from_type_lhs(lhs) or { return none }
    return t.generic_type_arg_bindings(generic_params, args)
}

fn (t &Transformer) generic_template_type_param_names_from_type_lhs(lhs ast.Expr) ?[]string {
    if base := t.generic_template_struct_from_type_lhs(lhs) {
        return base.generic_params.clone()
    }
    match lhs {
        ast.Ident {
            return t.generic_template_type_param_names_from_type_name(lhs.name)
        }
        ast.ModifierExpr {
            return t.generic_template_type_param_names_from_type_lhs(lhs.expr)
        }
        ast.PrefixExpr {
            return t.generic_template_type_param_names_from_type_lhs(lhs.expr)
        }
        else {}
    }

    return none
}

fn (t &Transformer) generic_template_type_param_names_from_type_name(name string) ?[]string {
    if name == '' {
        return none
    }
    if typ := t.lookup_type(name) {
        params := generic_template_type_param_names_from_type(typ)
        if params.len > 0 {
            return params
        }
    }
    if name.contains('_T_') {
        return t.generic_template_type_param_names_from_type_name(name.all_before('_T_'))
    }
    return none
}

fn generic_template_type_param_names_from_type(typ types.Type) []string {
    mut seen := map[string]bool{}
    mut structural_seen := map[string]bool{}
    mut names := []string{}
    collect_declared_generic_template_type_param_names(typ, mut seen, mut structural_seen, mut
        names)
    return names
}

fn generic_template_structural_seen_key(kind string, name string, generic_params []string) string {
    if name == '' {
        return ''
    }
    return '${kind}:${name}:${generic_params.join(',')}'
}

fn collect_declared_generic_template_type_param_names(typ types.Type, mut seen map[string]bool, mut structural_seen map[string]bool, mut names []string) {
    match typ {
        types.Alias {
            collect_declared_generic_template_type_param_names(typ.base_type, mut seen, mut
                structural_seen, mut names)
        }
        types.Array {
            collect_declared_generic_template_type_param_names(typ.elem_type, mut seen, mut
                structural_seen, mut names)
        }
        types.ArrayFixed {
            collect_declared_generic_template_type_param_names(typ.elem_type, mut seen, mut
                structural_seen, mut names)
        }
        types.Channel {
            if elem_type := typ.elem_type {
                collect_declared_generic_template_type_param_names(elem_type, mut seen, mut
                    structural_seen, mut names)
            }
        }
        types.Map {
            collect_declared_generic_template_type_param_names(typ.key_type, mut seen, mut
                structural_seen, mut names)
            collect_declared_generic_template_type_param_names(typ.value_type, mut seen, mut
                structural_seen, mut names)
        }
        types.NamedType {
            name := string(typ)
            if is_generic_placeholder_ident(name) && name !in seen {
                seen[name] = true
                names << name
            }
        }
        types.OptionType {
            collect_declared_generic_template_type_param_names(typ.base_type, mut seen, mut
                structural_seen, mut names)
        }
        types.Pointer {
            collect_declared_generic_template_type_param_names(typ.base_type, mut seen, mut
                structural_seen, mut names)
        }
        types.ResultType {
            collect_declared_generic_template_type_param_names(typ.base_type, mut seen, mut
                structural_seen, mut names)
        }
        types.Struct {
            for param in typ.generic_params {
                if is_generic_placeholder_ident(param) && param !in seen {
                    seen[param] = true
                    names << param
                }
            }
            struct_key := generic_template_structural_seen_key('struct', typ.name,
                typ.generic_params)
            if struct_key != '' {
                if structural_seen[struct_key] {
                    return
                }
                structural_seen[struct_key] = true
            }
            for field in typ.fields {
                collect_declared_generic_template_type_param_names(field.typ, mut seen, mut
                    structural_seen, mut names)
            }
            for embedded in typ.embedded {
                collect_declared_generic_template_type_param_names(types.Type(embedded), mut seen, mut
                    structural_seen, mut names)
            }
        }
        types.SumType {
            for param in typ.generic_params {
                if is_generic_placeholder_ident(param) && param !in seen {
                    seen[param] = true
                    names << param
                }
            }
            sumtype_key := generic_template_structural_seen_key('sumtype', typ.name,
                typ.generic_params)
            if sumtype_key != '' {
                if structural_seen[sumtype_key] {
                    return
                }
                structural_seen[sumtype_key] = true
            }
            if typ.generic_params.len > 0 {
                return
            }
            for variant in typ.variants {
                collect_declared_generic_template_type_param_names(variant, mut seen, mut
                    structural_seen, mut names)
            }
        }
        else {}
    }
}

fn (t &Transformer) generic_template_struct_from_type_lhs(lhs ast.Expr) ?types.Struct {
    match lhs {
        ast.Ident {
            return t.generic_template_struct_from_type_name(lhs.name)
        }
        ast.SelectorExpr {
            if lhs.lhs is ast.Ident {
                lhs_ident := lhs.lhs as ast.Ident
                mut module_names := []string{}
                if full_name := t.cur_import_aliases[lhs_ident.name] {
                    module_names << module_call_c_prefix(full_name)
                    module_names << full_name.replace('.', '__')
                }
                if prefix := t.resolve_module_call_prefix(lhs_ident.name) {
                    module_names << prefix
                }
                module_names << lhs_ident.name.replace('.', '__')
                mut seen := map[string]bool{}
                for module_name in module_names {
                    if module_name == '' || module_name in seen {
                        continue
                    }
                    seen[module_name] = true
                    if base := t.generic_template_struct_from_type_name('${module_name}__${lhs.rhs.name}') {
                        return base
                    }
                }
            }
            return t.generic_template_struct_from_type_name(lhs.rhs.name)
        }
        ast.ModifierExpr {
            return t.generic_template_struct_from_type_lhs(lhs.expr)
        }
        ast.PrefixExpr {
            return t.generic_template_struct_from_type_lhs(lhs.expr)
        }
        else {}
    }

    return none
}

fn (t &Transformer) generic_template_struct_from_type_name(name string) ?types.Struct {
    if name == '' {
        return none
    }
    if typ := t.lookup_type(name) {
        if typ is types.Struct && typ.generic_params.len > 0 {
            return typ
        }
    }
    if name.contains('_T_') {
        return t.generic_template_struct_from_type_name(name.all_before('_T_'))
    }
    return none
}

fn struct_decl_field_lookup_names(name string, module_name string) []string {
    if name == '' {
        return []string{}
    }
    mut names := [name]
    if module_name != '' && module_name != 'main' && module_name != 'builtin' {
        names << '${module_name.replace('.', '__')}__${name}'
    }
    return names
}

fn embedded_field_name_from_type_expr(expr ast.Expr) string {
    match expr {
        ast.Ident {
            return embedded_field_name_from_type_name(expr.name)
        }
        ast.SelectorExpr {
            return embedded_field_name_from_type_name(expr.rhs.name)
        }
        ast.GenericArgOrIndexExpr {
            return embedded_field_name_from_type_expr(expr.lhs)
        }
        ast.GenericArgs {
            return embedded_field_name_from_type_expr(expr.lhs)
        }
        ast.ModifierExpr {
            return embedded_field_name_from_type_expr(expr.expr)
        }
        ast.PrefixExpr {
            return embedded_field_name_from_type_expr(expr.expr)
        }
        ast.Type {
            match expr {
                ast.GenericType {
                    return embedded_field_name_from_type_expr(expr.name)
                }
                ast.PointerType {
                    return embedded_field_name_from_type_expr(expr.base_type)
                }
                else {
                    return ''
                }
            }
        }
        else {
            return ''
        }
    }
}

fn embedded_field_name_from_type_expr_cursor(expr ast.Cursor) string {
    match expr.kind() {
        .expr_ident {
            return embedded_field_name_from_type_name(expr.name())
        }
        .expr_selector {
            return embedded_field_name_from_type_name(selector_rhs_name_cursor(expr))
        }
        .expr_generic_arg_or_index, .expr_generic_args, .expr_index {
            return embedded_field_name_from_type_expr_cursor(expr.edge(0))
        }
        .expr_modifier, .expr_prefix {
            return embedded_field_name_from_type_expr_cursor(expr.edge(0))
        }
        .typ_generic {
            return embedded_field_name_from_type_expr_cursor(expr.edge(0))
        }
        .typ_pointer {
            return embedded_field_name_from_type_expr_cursor(expr.edge(0))
        }
        else {
            return ''
        }
    }
}

fn embedded_field_name_from_type_name(name string) string {
    if name == '' {
        return ''
    }
    mut field_name := if name.contains('__') { name.all_after_last('__') } else { name }
    if field_name.contains('.') {
        field_name = field_name.all_after_last('.')
    }
    if field_name.contains('_T_') {
        field_name = field_name.all_before('_T_')
    }
    return field_name
}

fn field_type_expr_has_generic_args(expr ast.Expr) bool {
    match expr {
        ast.GenericArgOrIndexExpr, ast.GenericArgs {
            return true
        }
        ast.ModifierExpr {
            return field_type_expr_has_generic_args(expr.expr)
        }
        ast.PrefixExpr {
            return field_type_expr_has_generic_args(expr.expr)
        }
        ast.Type {
            match expr {
                ast.ArrayType {
                    return field_type_expr_has_generic_args(expr.elem_type)
                }
                ast.ArrayFixedType {
                    return field_type_expr_has_generic_args(expr.elem_type)
                }
                ast.ChannelType {
                    return field_type_expr_has_generic_args(expr.elem_type)
                }
                ast.FnType {
                    for param in expr.params {
                        if field_type_expr_has_generic_args(param.typ) {
                            return true
                        }
                    }
                    return field_type_expr_has_generic_args(expr.return_type)
                }
                ast.GenericType {
                    return true
                }
                ast.MapType {
                    return field_type_expr_has_generic_args(expr.key_type)
                        || field_type_expr_has_generic_args(expr.value_type)
                }
                ast.OptionType {
                    return field_type_expr_has_generic_args(expr.base_type)
                }
                ast.PointerType {
                    return field_type_expr_has_generic_args(expr.base_type)
                }
                ast.ResultType {
                    return field_type_expr_has_generic_args(expr.base_type)
                }
                ast.ThreadType {
                    return field_type_expr_has_generic_args(expr.elem_type)
                }
                else {
                    return false
                }
            }
        }
        else {
            return false
        }
    }
}

fn field_type_cursor_has_generic_args(expr ast.Cursor) bool {
    match expr.kind() {
        .expr_generic_arg_or_index, .expr_generic_args {
            return true
        }
        .expr_modifier, .expr_prefix {
            return field_type_cursor_has_generic_args(expr.edge(0))
        }
        .typ_array {
            return field_type_cursor_has_generic_args(expr.edge(0))
        }
        .typ_array_fixed {
            return field_type_cursor_has_generic_args(expr.edge(1))
        }
        .typ_channel {
            return field_type_cursor_has_generic_args(expr.edge(1))
        }
        .typ_fn {
            params := expr.list_at(1)
            for i in 0 .. params.len() {
                if field_type_cursor_has_generic_args(params.at(i).edge(0)) {
                    return true
                }
            }
            return field_type_cursor_has_generic_args(expr.edge(2))
        }
        .typ_generic {
            return true
        }
        .typ_map {
            return field_type_cursor_has_generic_args(expr.edge(0))
                || field_type_cursor_has_generic_args(expr.edge(1))
        }
        .typ_option, .typ_pointer, .typ_result, .typ_thread {
            return field_type_cursor_has_generic_args(expr.edge(0))
        }
        .typ_tuple {
            for i in 0 .. expr.edge_count() {
                if field_type_cursor_has_generic_args(expr.edge(i)) {
                    return true
                }
            }
            return false
        }
        else {
            return false
        }
    }
}

fn (t &Transformer) generic_bindings_from_type_expr_cursor(expr ast.Cursor) ?map[string]types.Type {
    match expr.kind() {
        .expr_generic_args {
            base := t.lookup_type_from_expr_cursor(expr.edge(0)) or { return none }
            return t.generic_bindings_from_template_type_cursor(base, cursor_edges(expr, 1))
        }
        .expr_generic_arg_or_index {
            base := t.lookup_type_from_expr_cursor(expr.edge(0)) or { return none }
            return t.generic_bindings_from_template_type_cursor(base, [
                expr.edge(1),
            ])
        }
        .expr_modifier, .expr_prefix {
            return t.generic_bindings_from_type_expr_cursor(expr.edge(0))
        }
        .typ_generic {
            base := t.lookup_type_from_expr_cursor(expr.edge(0)) or { return none }
            return t.generic_bindings_from_template_type_cursor(base, cursor_edges(expr, 1))
        }
        .typ_pointer {
            return t.generic_bindings_from_type_expr_cursor(expr.edge(0))
        }
        else {}
    }

    return none
}

fn (t &Transformer) generic_bindings_from_template_type_cursor(base types.Type, args []ast.Cursor) ?map[string]types.Type {
    generic_params := generic_template_type_param_names_from_type(base)
    if generic_params.len == 0 {
        return none
    }
    arg_bindings := t.generic_type_arg_bindings_cursor(generic_params, args) or { return none }
    return arg_bindings.bindings.clone()
}

fn struct_field_generic_decl_key(struct_name string, field_name string) string {
    return '${struct_name}.${field_name}'
}

// monomorphize_pass walks env.generic_types, clones each generic FnDecl per
// binding map with concrete types substituted, and appends the clones to the
// owning file's stmts.
pub fn (mut t Transformer) monomorphize_pass(files []ast.File) []ast.File {
    // Index generic FnDecls by names that can appear in env.generic_types,
    // including module-qualified functions and method receiver keys.
    mut decl_owner := map[string]int{} // fn key -> file index
    mut decl_node := map[string]ast.FnDecl{}
    for fi, file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl {
                if decl_generic_param_names(stmt).len == 0 {
                    continue
                }
                t.index_generic_fn_decl_for_monomorphize(mut decl_owner, mut decl_node, stmt, fi,
                    file.mod)
            }
        }
    }
    // Per-file accumulator for cloned stmts (keyed by file index).
    mut per_file_clones := map[int][]ast.Stmt{}
    old_deferred_specs := t.deferred_generic_call_specs.clone()
    t.deferred_generic_call_specs = []DeferredGenericCallSpec{}
    for fn_key, bindings_list in t.env.generic_types {
        lookup_key := t.resolve_monomorphize_decl_key(fn_key, decl_node) or { continue }
        decl := decl_node[lookup_key] or { continue }
        fi := decl_owner[lookup_key] or { continue }
        for bindings in bindings_list {
            spec_name := t.specialized_fn_name(decl, bindings).clone()
            if spec_name == decl.name {
                continue
            }
            clone_name := t.monomorphized_clone_name(lookup_key, decl, spec_name, bindings).clone()
            clone_ast_name := t.monomorphized_clone_ast_name(decl, clone_name, bindings).clone()
            spec_key := '${lookup_key}:${clone_name}'.clone()
            if spec_key in t.monomorphized_specs {
                continue
            }
            t.monomorphized_specs[spec_key] = true
            owner_key := generic_spec_owner_key(fn_key, bindings)
            owner_file := t.generic_spec_owner_file[owner_key] or { fi }
            nested_struct_file := if t.generic_bindings_visible_in_module(files[fi].mod, bindings) {
                fi
            } else {
                owner_file
            }
            if nested_struct_file < 0 || nested_struct_file >= files.len {
                continue
            }
            clone_file := nested_struct_file
            t.register_monomorphized_fn_bindings(files[fi].mod, clone_name, bindings)
            old_owner_file := t.cur_generic_call_file_idx
            old_import_aliases := t.cur_import_aliases.clone()
            t.cur_generic_call_file_idx = clone_file
            t.cur_import_aliases = import_aliases_for_generic_collect(files[clone_file].imports)
            mut cloned := t.clone_fn_decl_with_substitutions(decl, bindings, clone_ast_name,
                files[fi].mod, files[clone_file].mod)
            if files[clone_file].mod != files[fi].mod {
                cloned = t.qualify_moved_clone_source_module_types(cloned, files[fi].mod)
            }
            t.cur_generic_call_file_idx = old_owner_file
            t.cur_import_aliases = old_import_aliases.clone()
            mut bucket := []ast.Stmt{}
            if clone_file in per_file_clones {
                bucket = per_file_clones[clone_file]
            }
            bucket << ast.Stmt(cloned)
            per_file_clones[clone_file] = bucket
        }
    }
    deferred_specs := t.deferred_generic_call_specs.clone()
    t.deferred_generic_call_specs = old_deferred_specs.clone()
    t.flush_deferred_generic_call_specs(deferred_specs)
    // Record the freshly-materialized clones so the fixpoint can rescan only
    // them (collect_generic_call_specs_in_new_clones) instead of all files.
    t.last_mono_clones = per_file_clones.clone()
    if per_file_clones.len == 0 {
        return files
    }
    mut new_files := []ast.File{cap: files.len}
    for fi, file in files {
        if fi !in per_file_clones {
            new_files << file
            continue
        }
        extra := per_file_clones[fi]
        mut stmts := file.stmts.clone()
        stmts << extra
        new_files << ast.File{
            attributes:     file.attributes
            mod:            file.mod
            name:           file.name
            stmts:          stmts
            imports:        file.imports
            selector_names: file.selector_names
        }
    }
    return new_files
}

fn (mut t Transformer) monomorphize_pass_from_flat(flat &ast.FlatAst, mut extra_stmts map[int][]ast.Stmt) {
    mut decl_owner := map[string]int{}
    mut decl_node := map[string]ast.FnDecl{}
    mut decl_cursor_ids := map[string]ast.FlatNodeId{}
    mut decl_extra_nodes := map[string]ast.FnDecl{}
    for fi in 0 .. flat.files.len {
        module_name := flat.file_mod(flat.files[fi])
        stmts := flat.file_cursor(fi).stmts()
        for si in 0 .. stmts.len() {
            stmt_c := stmts.at(si)
            if stmt_c.kind() != .stmt_fn_decl {
                continue
            }
            decl := stmt_c.fn_decl_signature()
            if decl_generic_param_names(decl).len == 0 {
                continue
            }
            for key in t.generic_fn_decl_monomorphize_keys(decl, module_name) {
                if key == '' || key in decl_node {
                    continue
                }
                decl_owner[key] = fi
                decl_node[key] = decl
                decl_cursor_ids[key] = stmt_c.id
            }
        }
        extra := extra_stmts[fi] or { []ast.Stmt{} }
        for stmt in extra {
            if stmt !is ast.FnDecl {
                continue
            }
            decl := stmt as ast.FnDecl
            if decl_generic_param_names(decl).len == 0 {
                continue
            }
            for key in t.generic_fn_decl_monomorphize_keys(decl, module_name) {
                if key == '' || key in decl_node {
                    continue
                }
                decl_owner[key] = fi
                decl_node[key] = decl
                decl_extra_nodes[key] = decl
            }
        }
    }
    mut per_file_clones := map[int][]ast.Stmt{}
    mut decl_full_cache := map[string]ast.FnDecl{}
    old_deferred_specs := t.deferred_generic_call_specs.clone()
    t.deferred_generic_call_specs = []DeferredGenericCallSpec{}
    for fn_key, bindings_list in t.env.generic_types {
        lookup_key := t.resolve_monomorphize_decl_key(fn_key, decl_node) or { continue }
        decl_sig := decl_node[lookup_key] or { continue }
        fi := decl_owner[lookup_key] or { continue }
        decl_mod := flat.file_mod(flat.files[fi])
        for bindings in bindings_list {
            spec_name := t.specialized_fn_name(decl_sig, bindings).clone()
            if spec_name == decl_sig.name {
                continue
            }
            clone_name :=
                t.monomorphized_clone_name(lookup_key, decl_sig, spec_name, bindings).clone()
            clone_ast_name := t.monomorphized_clone_ast_name(decl_sig, clone_name, bindings).clone()
            spec_key := '${lookup_key}:${clone_name}'.clone()
            if spec_key in t.monomorphized_specs {
                continue
            }
            t.monomorphized_specs[spec_key] = true
            owner_key := generic_spec_owner_key(fn_key, bindings)
            owner_file := t.generic_spec_owner_file[owner_key] or { fi }
            nested_struct_file := if t.generic_bindings_visible_in_module(decl_mod, bindings) {
                fi
            } else {
                owner_file
            }
            if nested_struct_file < 0 || nested_struct_file >= flat.files.len {
                continue
            }
            clone_file := nested_struct_file
            clone_mod := flat.file_mod(flat.files[clone_file])
            t.register_monomorphized_fn_bindings(decl_mod, clone_name, bindings)
            old_owner_file := t.cur_generic_call_file_idx
            old_import_aliases := t.cur_import_aliases.clone()
            t.cur_generic_call_file_idx = clone_file
            t.cur_import_aliases = flat_import_aliases_for_generic_collect(flat, clone_file)
            decl := decl_full_cache[lookup_key] or {
                full_decl := decl_extra_nodes[lookup_key] or {
                    cursor_id := decl_cursor_ids[lookup_key] or { ast.invalid_flat_node_id }
                    if cursor_id < 0 {
                        continue
                    }
                    decl_cursor := ast.Cursor{
                        flat: unsafe { flat }
                        id:   cursor_id
                    }
                    fn_decl_signature_with_body_cursor(decl_sig, decl_cursor)
                }
                decl_full_cache[lookup_key] = full_decl
                full_decl
            }
            mut cloned := t.clone_fn_decl_with_substitutions(decl, bindings, clone_ast_name,
                decl_mod, clone_mod)
            if clone_mod != decl_mod {
                cloned = t.qualify_moved_clone_source_module_types(cloned, decl_mod)
            }
            t.cur_generic_call_file_idx = old_owner_file
            t.cur_import_aliases = old_import_aliases.clone()
            mut bucket := per_file_clones[clone_file] or { []ast.Stmt{} }
            bucket << ast.Stmt(cloned)
            per_file_clones[clone_file] = bucket
        }
    }
    deferred_specs := t.deferred_generic_call_specs.clone()
    t.deferred_generic_call_specs = old_deferred_specs.clone()
    t.flush_deferred_generic_call_specs(deferred_specs)
    t.last_mono_clones = per_file_clones.clone()
    for fi, clones in per_file_clones {
        if clones.len == 0 {
            continue
        }
        append_flat_extra_stmts(mut extra_stmts, fi, clones)
    }
}

fn fn_decl_signature_with_body_cursor(signature ast.FnDecl, decl_cursor ast.Cursor) ast.FnDecl {
    return ast.FnDecl{
        attributes: signature.attributes
        is_public:  signature.is_public
        is_method:  signature.is_method
        is_static:  signature.is_static
        receiver:   signature.receiver
        language:   signature.language
        name:       signature.name
        typ:        signature.typ
        stmts:      decl_cursor.list_at(3).stmts()
        pos:        signature.pos
    }
}

fn (mut t Transformer) inject_generic_struct_specializations_from_flat(flat &ast.FlatAst, mut extra_stmts map[int][]ast.Stmt) {
    t.inject_changed_files = false
    t.last_struct_clones = map[int][]ast.Stmt{}
    if t.generic_struct_specs.len == 0 {
        return
    }
    mut existing := map[string]bool{}
    mut base_decls := map[string]ast.StructDecl{}
    for fi in 0 .. flat.files.len {
        module_name := flat.file_mod(flat.files[fi])
        for stmt in flat_file_struct_decls_with_extra(flat, extra_stmts, fi) {
            c_name := generic_struct_decl_c_name(stmt, module_name)
            existing[c_name] = true
            if stmt.generic_params.len > 0 {
                base_decls[c_name] = stmt
            }
        }
    }
    spec_keys := t.generic_struct_specs.keys()
    mut sorted_keys := spec_keys.clone()
    sorted_keys.sort()
    mut any_pending := false
    for key in sorted_keys {
        spec := t.generic_struct_specs[key] or { continue }
        if spec.concrete_c_name !in existing {
            any_pending = true
            break
        }
    }
    if !any_pending {
        return
    }
    for fi in 0 .. flat.files.len {
        module_name := flat.file_mod(flat.files[fi])
        mut injected := []ast.Stmt{}
        for key in sorted_keys {
            spec := t.generic_struct_specs[key] or { continue }
            if spec.file_idx < 0 || spec.file_idx >= flat.files.len || spec.file_idx != fi
                || spec.concrete_c_name in existing {
                continue
            }
            struct_decl := base_decls[spec.base_c_name] or { continue }
            cloned := ast.Stmt(t.clone_generic_struct_decl(struct_decl, spec, module_name))
            injected << cloned
            existing[spec.concrete_c_name] = true
        }
        for key in sorted_keys {
            spec := t.generic_struct_specs[key] or { continue }
            if (spec.file_idx >= 0 && spec.file_idx < flat.files.len)
                || spec.module_name != module_name
                || spec.concrete_c_name in existing {
                continue
            }
            struct_decl := base_decls[spec.base_c_name] or { continue }
            cloned := ast.Stmt(t.clone_generic_struct_decl(struct_decl, spec, module_name))
            injected << cloned
            existing[spec.concrete_c_name] = true
        }
        if injected.len > 0 {
            t.last_struct_clones[fi] = injected.clone()
            append_flat_extra_stmts(mut extra_stmts, fi, injected)
        }
    }
    t.inject_changed_files = true
}

fn (mut t Transformer) flush_deferred_generic_call_specs(specs []DeferredGenericCallSpec) {
    old_file_idx := t.cur_generic_call_file_idx
    for spec in specs {
        if spec.file_idx >= 0 {
            t.cur_generic_call_file_idx = spec.file_idx
        }
        t.register_generic_bindings(spec.base_name, spec.bindings)
    }
    t.cur_generic_call_file_idx = old_file_idx
}

fn (t &Transformer) qualify_moved_clone_source_module_types(decl ast.FnDecl, source_mod string) ast.FnDecl {
    if source_mod == '' || source_mod == 'main' || source_mod == 'builtin' {
        return decl
    }
    mut receiver := decl.receiver
    receiver.typ = t.qualify_moved_clone_type_expr(receiver.typ, source_mod)
    mut params := []ast.Parameter{cap: decl.typ.params.len}
    for param in decl.typ.params {
        params << ast.Parameter{
            name:   param.name
            typ:    t.qualify_moved_clone_type_expr(param.typ, source_mod)
            is_mut: param.is_mut
            pos:    param.pos
        }
    }
    mut stmts := []ast.Stmt{cap: decl.stmts.len}
    for stmt in decl.stmts {
        stmts << t.qualify_moved_clone_stmt_type_positions(stmt, source_mod)
    }
    return ast.FnDecl{
        attributes: decl.attributes
        is_public:  decl.is_public
        is_method:  decl.is_method
        is_static:  decl.is_static
        receiver:   receiver
        language:   decl.language
        name:       decl.name
        typ:        ast.FnType{
            generic_params: decl.typ.generic_params
            params:         params
            return_type:    t.qualify_moved_clone_type_expr(decl.typ.return_type, source_mod)
        }
        stmts:      stmts
        pos:        decl.pos
    }
}

fn (t &Transformer) qualify_moved_clone_type_expr(expr ast.Expr, source_mod string) ast.Expr {
    match expr {
        ast.Ident {
            if _ := t.get_synth_type(expr.pos) {
                return ast.Expr(expr)
            }
            if !t.should_qualify_moved_clone_type_name(expr.name, source_mod) {
                return ast.Expr(expr)
            }
            return ast.Expr(ast.Ident{
                name: '${source_mod}__${expr.name}'
                pos:  expr.pos
            })
        }
        ast.GenericArgOrIndexExpr {
            return ast.Expr(ast.GenericArgOrIndexExpr{
                lhs:  t.qualify_moved_clone_type_expr(expr.lhs, source_mod)
                expr: t.qualify_moved_clone_type_expr(expr.expr, source_mod)
                pos:  expr.pos
            })
        }
        ast.GenericArgs {
            mut args := []ast.Expr{cap: expr.args.len}
            for arg in expr.args {
                args << t.qualify_moved_clone_type_expr(arg, source_mod)
            }
            return ast.Expr(ast.GenericArgs{
                lhs:  t.qualify_moved_clone_type_expr(expr.lhs, source_mod)
                args: args
                pos:  expr.pos
            })
        }
        ast.ModifierExpr {
            return ast.Expr(ast.ModifierExpr{
                kind: expr.kind
                expr: t.qualify_moved_clone_type_expr(expr.expr, source_mod)
                pos:  expr.pos
            })
        }
        ast.PrefixExpr {
            return ast.Expr(ast.PrefixExpr{
                op:   expr.op
                expr: t.qualify_moved_clone_type_expr(expr.expr, source_mod)
                pos:  expr.pos
            })
        }
        ast.Type {
            return ast.Expr(t.qualify_moved_clone_type_node(expr, source_mod))
        }
        else {
            return expr
        }
    }
}

fn (t &Transformer) should_qualify_moved_clone_type_name(name string, source_mod string) bool {
    if name == '' || name.contains('__') || name.contains('.')
        || name in ['void', 'voidptr', 'byteptr', 'charptr', 'i8', 'i16', 'i32', 'int', 'i64', 'isize', 'u8', 'byte', 'u16', 'u32', 'u64', 'usize', 'f32', 'f64', 'char', 'rune', 'string', 'bool'] {
        return false
    }
    qualified := '${source_mod}__${name}'
    if _ := t.lookup_type(qualified) {
        return true
    }
    return false
}

fn (t &Transformer) should_qualify_moved_clone_fn_name(name string, source_mod string) bool {
    if name == '' || source_mod == '' || source_mod == 'main' || source_mod == 'builtin'
        || name.contains('__') || name.contains('.') {
        return false
    }
    base_name := generic_base_name_without_specialization(name)
    if base_name == '' {
        return false
    }
    if _ := t.lookup_fn_cached(source_mod, base_name) {
        return true
    }
    if _ := t.generic_fn_decl_for_call('${source_mod}__${base_name}') {
        return true
    }
    if _ := t.generic_fn_decl_for_call('${source_mod}.${base_name}') {
        return true
    }
    return false
}

fn (t &Transformer) qualify_moved_clone_type_node(typ ast.Type, source_mod string) ast.Type {
    match typ {
        ast.ArrayType {
            return ast.Type(ast.ArrayType{
                elem_type: t.qualify_moved_clone_type_expr(typ.elem_type, source_mod)
            })
        }
        ast.ArrayFixedType {
            return ast.Type(ast.ArrayFixedType{
                len:       typ.len
                elem_type: t.qualify_moved_clone_type_expr(typ.elem_type, source_mod)
            })
        }
        ast.ChannelType {
            return ast.Type(ast.ChannelType{
                cap:       typ.cap
                elem_type: t.qualify_moved_clone_type_expr(typ.elem_type, source_mod)
            })
        }
        ast.FnType {
            mut params := []ast.Parameter{cap: typ.params.len}
            for param in typ.params {
                params << ast.Parameter{
                    name:   param.name
                    typ:    t.qualify_moved_clone_type_expr(param.typ, source_mod)
                    is_mut: param.is_mut
                    pos:    param.pos
                }
            }
            return ast.Type(ast.FnType{
                generic_params: typ.generic_params
                params:         params
                return_type:    t.qualify_moved_clone_type_expr(typ.return_type, source_mod)
            })
        }
        ast.GenericType {
            mut params := []ast.Expr{cap: typ.params.len}
            for param in typ.params {
                params << t.qualify_moved_clone_type_expr(param, source_mod)
            }
            return ast.Type(ast.GenericType{
                name:   t.qualify_moved_clone_type_expr(typ.name, source_mod)
                params: params
            })
        }
        ast.MapType {
            return ast.Type(ast.MapType{
                key_type:   t.qualify_moved_clone_type_expr(typ.key_type, source_mod)
                value_type: t.qualify_moved_clone_type_expr(typ.value_type, source_mod)
            })
        }
        ast.OptionType {
            return ast.Type(ast.OptionType{
                base_type: t.qualify_moved_clone_type_expr(typ.base_type, source_mod)
            })
        }
        ast.PointerType {
            return ast.Type(ast.PointerType{
                base_type: t.qualify_moved_clone_type_expr(typ.base_type, source_mod)
                lifetime:  typ.lifetime
            })
        }
        ast.ResultType {
            return ast.Type(ast.ResultType{
                base_type: t.qualify_moved_clone_type_expr(typ.base_type, source_mod)
            })
        }
        ast.ThreadType {
            return ast.Type(ast.ThreadType{
                elem_type: t.qualify_moved_clone_type_expr(typ.elem_type, source_mod)
            })
        }
        else {
            return typ
        }
    }
}

fn (t &Transformer) qualify_moved_clone_stmt_type_positions(stmt ast.Stmt, source_mod string) ast.Stmt {
    match stmt {
        ast.AssertStmt {
            return ast.Stmt(ast.AssertStmt{
                expr:  t.qualify_moved_clone_expr_type_positions(stmt.expr, source_mod)
                extra: t.qualify_moved_clone_expr_type_positions(stmt.extra, source_mod)
            })
        }
        ast.AssignStmt {
            mut lhs := []ast.Expr{cap: stmt.lhs.len}
            for expr in stmt.lhs {
                lhs << t.qualify_moved_clone_expr_type_positions(expr, source_mod)
            }
            mut rhs := []ast.Expr{cap: stmt.rhs.len}
            for expr in stmt.rhs {
                rhs << t.qualify_moved_clone_expr_type_positions(expr, source_mod)
            }
            return ast.Stmt(ast.AssignStmt{
                op:  stmt.op
                lhs: lhs
                rhs: rhs
                pos: stmt.pos
            })
        }
        ast.BlockStmt {
            mut stmts := []ast.Stmt{cap: stmt.stmts.len}
            for child in stmt.stmts {
                stmts << t.qualify_moved_clone_stmt_type_positions(child, source_mod)
            }
            return ast.Stmt(ast.BlockStmt{
                stmts: stmts
            })
        }
        ast.ComptimeStmt {
            return ast.Stmt(ast.ComptimeStmt{
                stmt: t.qualify_moved_clone_stmt_type_positions(stmt.stmt, source_mod)
            })
        }
        ast.ConstDecl {
            mut fields := []ast.FieldInit{cap: stmt.fields.len}
            for field in stmt.fields {
                fields << ast.FieldInit{
                    name:  field.name
                    value: t.qualify_moved_clone_expr_type_positions(field.value, source_mod)
                }
            }
            return ast.Stmt(ast.ConstDecl{
                fields: fields
            })
        }
        ast.DeferStmt {
            mut stmts := []ast.Stmt{cap: stmt.stmts.len}
            for child in stmt.stmts {
                stmts << t.qualify_moved_clone_stmt_type_positions(child, source_mod)
            }
            return ast.Stmt(ast.DeferStmt{
                mode:  stmt.mode
                stmts: stmts
            })
        }
        ast.ExprStmt {
            return ast.Stmt(ast.ExprStmt{
                expr: t.qualify_moved_clone_expr_type_positions(stmt.expr, source_mod)
            })
        }
        ast.ForInStmt {
            return ast.Stmt(ast.ForInStmt{
                key:   t.qualify_moved_clone_expr_type_positions(stmt.key, source_mod)
                value: t.qualify_moved_clone_expr_type_positions(stmt.value, source_mod)
                expr:  t.qualify_moved_clone_expr_type_positions(stmt.expr, source_mod)
            })
        }
        ast.ForStmt {
            mut stmts := []ast.Stmt{cap: stmt.stmts.len}
            for child in stmt.stmts {
                stmts << t.qualify_moved_clone_stmt_type_positions(child, source_mod)
            }
            return ast.Stmt(ast.ForStmt{
                init:  t.qualify_moved_clone_stmt_type_positions(stmt.init, source_mod)
                cond:  t.qualify_moved_clone_expr_type_positions(stmt.cond, source_mod)
                post:  t.qualify_moved_clone_stmt_type_positions(stmt.post, source_mod)
                stmts: stmts
            })
        }
        ast.GlobalDecl {
            mut fields := []ast.FieldDecl{cap: stmt.fields.len}
            for field in stmt.fields {
                fields << ast.FieldDecl{
                    name:                field.name
                    typ:                 t.qualify_moved_clone_type_expr(field.typ, source_mod)
                    value:               t.qualify_moved_clone_expr_type_positions(field.value,
                        source_mod)
                    attributes:          field.attributes
                    is_public:           field.is_public
                    is_mut:              field.is_mut
                    is_module_mut:       field.is_module_mut
                    is_interface_method: field.is_interface_method
                }
            }
            return ast.Stmt(ast.GlobalDecl{
                attributes: stmt.attributes
                fields:     fields
                is_public:  stmt.is_public
            })
        }
        ast.LabelStmt {
            return ast.Stmt(ast.LabelStmt{
                name: stmt.name
                stmt: t.qualify_moved_clone_stmt_type_positions(stmt.stmt, source_mod)
            })
        }
        ast.ReturnStmt {
            mut exprs := []ast.Expr{cap: stmt.exprs.len}
            for expr in stmt.exprs {
                exprs << t.qualify_moved_clone_expr_type_positions(expr, source_mod)
            }
            return ast.Stmt(ast.ReturnStmt{
                exprs: exprs
            })
        }
        else {
            return stmt
        }
    }
}

fn (t &Transformer) qualify_moved_clone_expr_type_positions(expr ast.Expr, source_mod string) ast.Expr {
    match expr {
        ast.Ident {
            if expr.name.contains('_T_')
                && t.should_qualify_moved_clone_fn_name(expr.name, source_mod) {
                return ast.Expr(ast.Ident{
                    name: '${source_mod}__${expr.name}'
                    pos:  expr.pos
                })
            }
            return ast.Expr(expr)
        }
        ast.ArrayInitExpr {
            mut exprs := []ast.Expr{cap: expr.exprs.len}
            for item in expr.exprs {
                exprs << t.qualify_moved_clone_expr_type_positions(item, source_mod)
            }
            return ast.Expr(ast.ArrayInitExpr{
                typ:         t.qualify_moved_clone_type_expr(expr.typ, source_mod)
                exprs:       exprs
                init:        t.qualify_moved_clone_expr_type_positions(expr.init, source_mod)
                cap:         t.qualify_moved_clone_expr_type_positions(expr.cap, source_mod)
                len:         t.qualify_moved_clone_expr_type_positions(expr.len, source_mod)
                update_expr: t.qualify_moved_clone_expr_type_positions(expr.update_expr, source_mod)
                pos:         expr.pos
            })
        }
        ast.AsCastExpr {
            return ast.Expr(ast.AsCastExpr{
                expr: t.qualify_moved_clone_expr_type_positions(expr.expr, source_mod)
                typ:  t.qualify_moved_clone_type_expr(expr.typ, source_mod)
                pos:  expr.pos
            })
        }
        ast.AssocExpr {
            mut fields := []ast.FieldInit{cap: expr.fields.len}
            for field in expr.fields {
                fields << ast.FieldInit{
                    name:  field.name
                    value: t.qualify_moved_clone_expr_type_positions(field.value, source_mod)
                }
            }
            return ast.Expr(ast.AssocExpr{
                typ:    t.qualify_moved_clone_type_expr(expr.typ, source_mod)
                expr:   t.qualify_moved_clone_expr_type_positions(expr.expr, source_mod)
                fields: fields
                pos:    expr.pos
            })
        }
        ast.CallExpr {
            mut args := []ast.Expr{cap: expr.args.len}
            for arg in expr.args {
                args << t.qualify_moved_clone_expr_type_positions(arg, source_mod)
            }
            return ast.Expr(ast.CallExpr{
                lhs:  t.qualify_moved_clone_call_lhs_type_positions(expr.lhs, source_mod)
                args: args
                pos:  expr.pos
            })
        }
        ast.CallOrCastExpr {
            return ast.Expr(ast.CallOrCastExpr{
                lhs:  t.qualify_moved_clone_call_lhs_type_positions(expr.lhs, source_mod)
                expr: t.qualify_moved_clone_expr_type_positions(expr.expr, source_mod)
                pos:  expr.pos
            })
        }
        ast.CastExpr {
            return ast.Expr(ast.CastExpr{
                typ:  t.qualify_moved_clone_type_expr(expr.typ, source_mod)
                expr: t.qualify_moved_clone_expr_type_positions(expr.expr, source_mod)
                pos:  expr.pos
            })
        }
        ast.ComptimeExpr {
            return ast.Expr(ast.ComptimeExpr{
                expr: t.qualify_moved_clone_expr_type_positions(expr.expr, source_mod)
                pos:  expr.pos
            })
        }
        ast.FieldInit {
            return ast.Expr(ast.FieldInit{
                name:  expr.name
                value: t.qualify_moved_clone_expr_type_positions(expr.value, source_mod)
            })
        }
        ast.IfExpr {
            mut stmts := []ast.Stmt{cap: expr.stmts.len}
            for stmt in expr.stmts {
                stmts << t.qualify_moved_clone_stmt_type_positions(stmt, source_mod)
            }
            return ast.Expr(ast.IfExpr{
                cond:      t.qualify_moved_clone_expr_type_positions(expr.cond, source_mod)
                stmts:     stmts
                else_expr: t.qualify_moved_clone_expr_type_positions(expr.else_expr, source_mod)
                pos:       expr.pos
            })
        }
        ast.IfGuardExpr {
            stmt := t.qualify_moved_clone_stmt_type_positions(ast.Stmt(expr.stmt), source_mod)
            if stmt is ast.AssignStmt {
                return ast.Expr(ast.IfGuardExpr{
                    stmt: stmt
                    pos:  expr.pos
                })
            }
            return expr
        }
        ast.IndexExpr {
            return ast.Expr(ast.IndexExpr{
                lhs:      t.qualify_moved_clone_expr_type_positions(expr.lhs, source_mod)
                expr:     t.qualify_moved_clone_expr_type_positions(expr.expr, source_mod)
                is_gated: expr.is_gated
                pos:      expr.pos
            })
        }
        ast.InfixExpr {
            return ast.Expr(ast.InfixExpr{
                op:  expr.op
                lhs: t.qualify_moved_clone_expr_type_positions(expr.lhs, source_mod)
                rhs: t.qualify_moved_clone_expr_type_positions(expr.rhs, source_mod)
                pos: expr.pos
            })
        }
        ast.InitExpr {
            mut fields := []ast.FieldInit{cap: expr.fields.len}
            for field in expr.fields {
                fields << ast.FieldInit{
                    name:  field.name
                    value: t.qualify_moved_clone_expr_type_positions(field.value, source_mod)
                }
            }
            return ast.Expr(ast.InitExpr{
                typ:    t.qualify_moved_clone_type_expr(expr.typ, source_mod)
                fields: fields
                pos:    expr.pos
            })
        }
        ast.KeywordOperator {
            mut exprs := []ast.Expr{cap: expr.exprs.len}
            for item in expr.exprs {
                exprs << t.qualify_moved_clone_expr_type_positions(item, source_mod)
            }
            return ast.Expr(ast.KeywordOperator{
                op:    expr.op
                exprs: exprs
                pos:   expr.pos
            })
        }
        ast.LockExpr {
            mut lock_exprs := []ast.Expr{cap: expr.lock_exprs.len}
            for item in expr.lock_exprs {
                lock_exprs << t.qualify_moved_clone_expr_type_positions(item, source_mod)
            }
            mut rlock_exprs := []ast.Expr{cap: expr.rlock_exprs.len}
            for item in expr.rlock_exprs {
                rlock_exprs << t.qualify_moved_clone_expr_type_positions(item, source_mod)
            }
            mut stmts := []ast.Stmt{cap: expr.stmts.len}
            for stmt in expr.stmts {
                stmts << t.qualify_moved_clone_stmt_type_positions(stmt, source_mod)
            }
            return ast.Expr(ast.LockExpr{
                lock_exprs:  lock_exprs
                rlock_exprs: rlock_exprs
                stmts:       stmts
                pos:         expr.pos
            })
        }
        ast.MapInitExpr {
            mut keys := []ast.Expr{cap: expr.keys.len}
            for key in expr.keys {
                keys << t.qualify_moved_clone_expr_type_positions(key, source_mod)
            }
            mut vals := []ast.Expr{cap: expr.vals.len}
            for val in expr.vals {
                vals << t.qualify_moved_clone_expr_type_positions(val, source_mod)
            }
            return ast.Expr(ast.MapInitExpr{
                typ:  t.qualify_moved_clone_type_expr(expr.typ, source_mod)
                keys: keys
                vals: vals
                pos:  expr.pos
            })
        }
        ast.MatchExpr {
            mut branches := []ast.MatchBranch{cap: expr.branches.len}
            for branch in expr.branches {
                mut conds := []ast.Expr{cap: branch.cond.len}
                for cond in branch.cond {
                    conds << t.qualify_moved_clone_type_expr(cond, source_mod)
                }
                mut stmts := []ast.Stmt{cap: branch.stmts.len}
                for stmt in branch.stmts {
                    stmts << t.qualify_moved_clone_stmt_type_positions(stmt, source_mod)
                }
                branches << ast.MatchBranch{
                    cond:  conds
                    stmts: stmts
                    pos:   branch.pos
                }
            }
            return ast.Expr(ast.MatchExpr{
                expr:     t.qualify_moved_clone_expr_type_positions(expr.expr, source_mod)
                branches: branches
                pos:      expr.pos
            })
        }
        ast.ModifierExpr {
            return ast.Expr(ast.ModifierExpr{
                kind: expr.kind
                expr: t.qualify_moved_clone_expr_type_positions(expr.expr, source_mod)
                pos:  expr.pos
            })
        }
        ast.OrExpr {
            mut stmts := []ast.Stmt{cap: expr.stmts.len}
            for stmt in expr.stmts {
                stmts << t.qualify_moved_clone_stmt_type_positions(stmt, source_mod)
            }
            return ast.Expr(ast.OrExpr{
                expr:  t.qualify_moved_clone_expr_type_positions(expr.expr, source_mod)
                stmts: stmts
                pos:   expr.pos
            })
        }
        ast.ParenExpr {
            return ast.Expr(ast.ParenExpr{
                expr: t.qualify_moved_clone_expr_type_positions(expr.expr, source_mod)
                pos:  expr.pos
            })
        }
        ast.PostfixExpr {
            return ast.Expr(ast.PostfixExpr{
                op:   expr.op
                expr: t.qualify_moved_clone_expr_type_positions(expr.expr, source_mod)
                pos:  expr.pos
            })
        }
        ast.PrefixExpr {
            return ast.Expr(ast.PrefixExpr{
                op:   expr.op
                expr: t.qualify_moved_clone_expr_type_positions(expr.expr, source_mod)
                pos:  expr.pos
            })
        }
        ast.RangeExpr {
            return ast.Expr(ast.RangeExpr{
                op:    expr.op
                start: t.qualify_moved_clone_expr_type_positions(expr.start, source_mod)
                end:   t.qualify_moved_clone_expr_type_positions(expr.end, source_mod)
                pos:   expr.pos
            })
        }
        ast.SelectExpr {
            mut stmts := []ast.Stmt{cap: expr.stmts.len}
            for stmt in expr.stmts {
                stmts << t.qualify_moved_clone_stmt_type_positions(stmt, source_mod)
            }
            return ast.Expr(ast.SelectExpr{
                stmt:  t.qualify_moved_clone_stmt_type_positions(expr.stmt, source_mod)
                stmts: stmts
                next:  t.qualify_moved_clone_expr_type_positions(expr.next, source_mod)
                pos:   expr.pos
            })
        }
        ast.SelectorExpr {
            return ast.Expr(ast.SelectorExpr{
                lhs: t.qualify_moved_clone_expr_type_positions(expr.lhs, source_mod)
                rhs: expr.rhs
                pos: expr.pos
            })
        }
        ast.StringInterLiteral {
            mut inters := []ast.StringInter{cap: expr.inters.len}
            for inter in expr.inters {
                inters << ast.StringInter{
                    format:       inter.format
                    width:        inter.width
                    precision:    inter.precision
                    expr:         t.qualify_moved_clone_expr_type_positions(inter.expr, source_mod)
                    format_expr:  t.qualify_moved_clone_expr_type_positions(inter.format_expr,
                        source_mod)
                    resolved_fmt: inter.resolved_fmt
                }
            }
            return ast.Expr(ast.StringInterLiteral{
                kind:   expr.kind
                values: expr.values
                inters: inters
                pos:    expr.pos
            })
        }
        ast.Tuple {
            mut exprs := []ast.Expr{cap: expr.exprs.len}
            for item in expr.exprs {
                exprs << t.qualify_moved_clone_expr_type_positions(item, source_mod)
            }
            return ast.Expr(ast.Tuple{
                exprs: exprs
                pos:   expr.pos
            })
        }
        ast.Type {
            return ast.Expr(t.qualify_moved_clone_type_node(expr, source_mod))
        }
        ast.UnsafeExpr {
            mut stmts := []ast.Stmt{cap: expr.stmts.len}
            for stmt in expr.stmts {
                stmts << t.qualify_moved_clone_stmt_type_positions(stmt, source_mod)
            }
            return ast.Expr(ast.UnsafeExpr{
                stmts: stmts
                pos:   expr.pos
            })
        }
        else {
            return expr
        }
    }
}

fn (t &Transformer) qualify_moved_clone_call_lhs_type_positions(expr ast.Expr, source_mod string) ast.Expr {
    match expr {
        ast.Ident {
            if t.should_qualify_moved_clone_fn_name(expr.name, source_mod) {
                return ast.Expr(ast.Ident{
                    name: '${source_mod}__${expr.name}'
                    pos:  expr.pos
                })
            }
            return ast.Expr(expr)
        }
        ast.GenericArgOrIndexExpr {
            return ast.Expr(ast.GenericArgOrIndexExpr{
                lhs:  t.qualify_moved_clone_call_lhs_type_positions(expr.lhs, source_mod)
                expr: t.qualify_moved_clone_type_expr(expr.expr, source_mod)
                pos:  expr.pos
            })
        }
        ast.GenericArgs {
            mut args := []ast.Expr{cap: expr.args.len}
            for arg in expr.args {
                args << t.qualify_moved_clone_type_expr(arg, source_mod)
            }
            return ast.Expr(ast.GenericArgs{
                lhs:  t.qualify_moved_clone_call_lhs_type_positions(expr.lhs, source_mod)
                args: args
                pos:  expr.pos
            })
        }
        else {
            return t.qualify_moved_clone_expr_type_positions(expr, source_mod)
        }
    }
}

fn (t &Transformer) monomorphized_clone_name(fn_key string, decl ast.FnDecl, spec_name string, bindings map[string]types.Type) string {
    if decl.is_method {
        short_name := t.specialized_receiver_method_name(decl, bindings) or { spec_name }
        return t.qualify_receiver_generic_method_call_name(fn_key, decl, short_name) or {
            short_name
        }
    }
    base_name := generic_base_name_without_specialization(fn_key)
    if base_name.ends_with('__${decl.name}') {
        return '${base_name.all_before_last('__')}__${spec_name}'
    }
    if base_name.ends_with('.${decl.name}') {
        return '${base_name.all_before_last('.').replace('.', '__')}__${spec_name}'
    }
    return spec_name
}

fn (t &Transformer) monomorphized_clone_ast_name(decl ast.FnDecl, clone_name string, bindings map[string]types.Type) string {
    if decl.is_method {
        return t.specialized_method_name_without_receiver(decl, bindings)
    }
    return clone_name
}

fn (t &Transformer) specialized_receiver_method_name(decl ast.FnDecl, bindings map[string]types.Type) ?string {
    receiver_name := t.specialized_receiver_type_name(decl.receiver.typ, bindings) or {
        return none
    }
    method_name := t.specialized_method_name_without_receiver(decl, bindings)
    if method_name == '' {
        return none
    }
    return '${receiver_name}__${method_name}'
}

fn (t &Transformer) specialized_method_name_without_receiver(decl ast.FnDecl, bindings map[string]types.Type) string {
    method_params := generic_param_names(decl.typ.generic_params)
    if method_params.len == 0 {
        return decl.name
    }
    mut all_placeholders := true
    mut concrete_parts := []string{cap: method_params.len}
    for gp_name in method_params {
        concrete := bindings[gp_name] or {
            concrete_parts << gp_name
            continue
        }
        concrete_parts << t.generic_specialization_token_from_type(concrete)
        if concrete.name() != gp_name {
            all_placeholders = false
        }
    }
    if all_placeholders {
        return decl.name + '_' + method_params.join('_')
    }
    return decl.name + '_T_' + concrete_parts.join('_')
}

fn (t &Transformer) specialized_receiver_type_name(expr ast.Expr, bindings map[string]types.Type) ?string {
    match expr {
        ast.GenericArgs {
            return t.specialized_receiver_type_name_from_parts(expr.lhs, expr.args, bindings)
        }
        ast.GenericArgOrIndexExpr {
            return t.specialized_receiver_type_name_from_parts(expr.lhs, [expr.expr], bindings)
        }
        ast.ModifierExpr {
            return t.specialized_receiver_type_name(expr.expr, bindings)
        }
        ast.PrefixExpr {
            return t.specialized_receiver_type_name(expr.expr, bindings)
        }
        ast.Type {
            match expr {
                ast.GenericType {
                    return t.specialized_receiver_type_name_from_parts(expr.name, expr.params,
                        bindings)
                }
                ast.PointerType {
                    return t.specialized_receiver_type_name(expr.base_type, bindings)
                }
                else {}
            }
        }
        else {}
    }

    return none
}

fn (t &Transformer) specialized_receiver_type_name_from_parts(lhs ast.Expr, args []ast.Expr, bindings map[string]types.Type) ?string {
    base_name := t.get_receiver_type_name(lhs)
    if base_name == '' || args.len == 0 {
        return none
    }
    mut parts := []string{cap: args.len}
    for arg in args {
        concrete := t.concrete_type_from_receiver_generic_arg(arg, bindings) or { return none }
        parts << t.generic_specialization_token_from_type(concrete)
    }
    return '${base_name}_T_${parts.join('_')}'
}

fn (t &Transformer) concrete_type_from_receiver_generic_arg(arg ast.Expr, bindings map[string]types.Type) ?types.Type {
    if arg is ast.Ident {
        if concrete := bindings[arg.name] {
            return concrete
        }
    }
    if typ := t.type_from_param_type_expr(arg, []) {
        return substitute_type(typ, bindings)
    }
    if typ := t.get_expr_type(arg) {
        return substitute_type(typ, bindings)
    }
    return none
}

fn generic_base_name_without_specialization(name string) string {
    // Hot path: called per-method per-call-site during generic collection.
    // Hand-rolled byte scans replace string.contains/.index/.all_before, each of
    // which builds a fresh KMP failure-table heap allocation on every call. With
    // millions of calls (and most names having neither `[` nor `_T_`) that
    // allocation churn dominated the whole transform stage. This is behaviour-
    // identical to the previous index_u8(`[`)>0 / contains('_T_') / ends_with('_T')
    // version, just without the per-call allocations.
    mut end := name.len
    for i in 0 .. name.len {
        if name[i] == `[` {
            if i > 0 {
                end = i
            }
            break
        }
    }
    for i := 0; i + 3 <= end; i++ {
        if name[i] == `_` && name[i + 1] == `T` && name[i + 2] == `_` {
            return name[..i]
        }
    }
    if end >= 2 && name[end - 1] == `T` && name[end - 2] == `_` {
        return name[..end - 2]
    }
    if end == name.len {
        return name
    }
    return name[..end]
}

// method_short_name returns the final `__`-separated segment of s (after a
// `.`->`__` normalization). It matches the short form method_key_matches_type_name
// compares, so it can be used to bucket method keys for fast candidate lookup.
fn method_short_name(s string) string {
    norm := if s.index_u8(`.`) >= 0 { s.replace('.', '__') } else { s }
    d := last_double_underscore(norm)
    return if d >= 0 { norm[d + 2..] } else { norm }
}

// last_double_underscore returns the index of the last `__` in s, or -1.
// Hand-rolled (no allocation) replacement for s.contains('__') / .all_after_last('__'),
// which build KMP tables / allocate; used in hot per-call-site name matching.
fn last_double_underscore(s string) int {
    mut i := s.len - 2
    for i >= 0 {
        if s[i] == `_` && s[i + 1] == `_` {
            return i
        }
        i--
    }
    return -1
}

fn (mut t Transformer) generic_fn_decl_monomorphize_keys(decl ast.FnDecl, module_name string) []string {
    mut keys := []string{}
    if !decl.is_method {
        keys << decl.name
        if module_name != '' {
            keys << '${module_name}.${decl.name}'
            keys << '${module_name.replace('.', '__')}__${decl.name}'
            call_prefix := module_call_c_prefix(module_name)
            if call_prefix != '' {
                keys << '${call_prefix}__${decl.name}'
            }
        }
    } else {
        recv_name := t.get_receiver_type_name(decl.receiver.typ)
        if recv_name != '' {
            keys << '${recv_name}__${decl.name}'
            if module_name != '' && !recv_name.contains('__') {
                keys << '${module_name.replace('.', '__')}__${recv_name}__${decl.name}'
                call_prefix := module_call_c_prefix(module_name)
                if call_prefix != '' {
                    keys << '${call_prefix}__${recv_name}__${decl.name}'
                }
            }
        }
    }
    return keys
}

fn (mut t Transformer) index_generic_fn_decl_for_monomorphize(mut decl_owner map[string]int, mut decl_node map[string]ast.FnDecl, decl ast.FnDecl, file_idx int, module_name string) {
    keys := t.generic_fn_decl_monomorphize_keys(decl, module_name)
    for key in keys {
        if key == '' {
            continue
        }
        if key in decl_node {
            continue
        }
        decl_owner[key] = file_idx
        decl_node[key] = decl
    }
}

fn (t &Transformer) resolve_monomorphize_decl_key(fn_key string, decl_node map[string]ast.FnDecl) ?string {
    if fn_key in decl_node {
        return fn_key
    }
    mut base_name := fn_key
    bracket_pos := base_name.index_u8(`[`)
    if bracket_pos > 0 {
        base_name = base_name[..bracket_pos]
    }
    if base_name in decl_node {
        return base_name
    }
    if base_name.contains('.') {
        c_name := base_name.replace('.', '__')
        if c_name in decl_node {
            return c_name
        }
    }
    if base_name.contains('__') {
        mut suffix_name := base_name.all_after('__')
        for suffix_name.contains('__') {
            if suffix_name in decl_node {
                return suffix_name
            }
            suffix_name = suffix_name.all_after('__')
        }
    }
    return none
}

fn (t &Transformer) resolve_generic_decl_key_for_call(base_name string, decl_node map[string]ast.FnDecl) ?string {
    if receiver_template := receiver_specialized_method_template_name(base_name) {
        if key := t.resolve_monomorphize_decl_key(receiver_template, decl_node) {
            return key
        }
    }
    mut name := generic_base_name_without_specialization(base_name)
    bracket_pos := name.index_u8(`[`)
    if bracket_pos > 0 {
        name = name[..bracket_pos]
    }
    if name == '' {
        return none
    }
    if !name.contains('__') && !name.contains('.') && t.cur_module != ''
        && t.cur_module != 'builtin' {
        if t.cur_module != 'main' {
            call_prefix := module_call_c_prefix(t.cur_module)
            if call_prefix != '' {
                candidate := '${call_prefix}__${name}'
                if candidate in decl_node {
                    return candidate
                }
            }
            module_prefix := t.cur_module.replace('.', '__')
            if module_prefix != '' {
                candidate := '${module_prefix}__${name}'
                if candidate in decl_node {
                    return candidate
                }
            }
            candidate := '${t.cur_module}.${name}'
            if candidate in decl_node {
                return candidate
            }
        }
        if t.has_current_module_concrete_fn(name) {
            return none
        }
    }
    return t.resolve_monomorphize_decl_key(name, decl_node)
}

fn receiver_specialized_method_template_name(name string) ?string {
    if name == '' {
        return none
    }
    mut base := name
    bracket_pos := base.index_u8(`[`)
    if bracket_pos > 0 {
        base = base[..bracket_pos]
    }
    t_idx := base.index('_T_') or { return none }
    method_sep := first_double_underscore_after(base, t_idx + 3)
    if method_sep < 0 || method_sep + 2 >= base.len {
        return none
    }
    receiver_base := base[..t_idx]
    if receiver_base == '' {
        return none
    }
    return receiver_base + base[method_sep..]
}

fn first_double_underscore_after(s string, start int) int {
    mut i := if start < 0 { 0 } else { start }
    for i + 1 < s.len {
        if s[i] == `_` && s[i + 1] == `_` {
            return i
        }
        i++
    }
    return -1
}

fn (t &Transformer) has_current_module_concrete_fn(name string) bool {
    return t.has_concrete_fn_in_module(t.cur_module, name)
        || (t.cur_module == 'main' && t.has_concrete_fn_in_module('', name))
}

fn (t &Transformer) has_concrete_fn_in_module(module_name string, name string) bool {
    if fn_type := t.lookup_fn_cached(module_name, name) {
        return fn_type.get_generic_params().len == 0
    }
    scope := t.get_module_scope(module_name) or { return false }
    obj := scope.objects[name] or { return false }
    if obj is types.Fn {
        typ := obj.get_typ()
        if typ is types.FnType {
            return typ.get_generic_params().len == 0
        }
    }
    return false
}

fn (mut t Transformer) collect_generic_call_specs(files []ast.File) {
    old_module := t.cur_module
    old_file := t.cur_file_name
    old_scope := t.scope
    old_file_idx := t.cur_generic_call_file_idx
    old_import_aliases := t.cur_import_aliases.clone()
    t.build_generic_fn_decl_index(files)
    for fi, file in files {
        t.cur_file_name = file.name
        t.cur_module = file.mod
        t.cur_generic_call_file_idx = fi
        t.cur_import_aliases = import_aliases_for_generic_collect(file.imports)
        if scope := t.get_module_scope(file.mod) {
            t.scope = scope
        } else {
            t.scope = unsafe { nil }
        }
        for stmt in file.stmts {
            t.collect_generic_call_specs_in_stmt(stmt)
        }
    }
    t.cur_module = old_module
    t.cur_file_name = old_file
    t.scope = old_scope
    t.cur_generic_call_file_idx = old_file_idx
    t.cur_import_aliases = old_import_aliases.clone()
}

fn (mut t Transformer) collect_generic_call_specs_from_flat(flat &ast.FlatAst, extra_stmts map[int][]ast.Stmt) {
    old_module := t.cur_module
    old_file := t.cur_file_name
    old_scope := t.scope
    old_file_idx := t.cur_generic_call_file_idx
    old_import_aliases := t.cur_import_aliases.clone()
    t.build_generic_fn_decl_index_from_flat(flat, extra_stmts)
    for fi in 0 .. flat.files.len {
        module_name := flat.file_mod(flat.files[fi])
        t.cur_file_name = flat.file_name(flat.files[fi])
        t.cur_module = module_name
        t.cur_generic_call_file_idx = fi
        t.cur_import_aliases = flat_import_aliases_for_generic_collect(flat, fi)
        if scope := t.get_module_scope(module_name) {
            t.scope = scope
        } else {
            t.scope = unsafe { nil }
        }
        stmts := flat.file_cursor(fi).stmts()
        for si in 0 .. stmts.len() {
            t.collect_generic_call_specs_in_stmt_cursor(stmts.at(si))
        }
        extra := extra_stmts[fi] or { []ast.Stmt{} }
        for stmt in extra {
            t.collect_generic_call_specs_in_stmt(stmt)
        }
    }
    t.cur_module = old_module
    t.cur_file_name = old_file
    t.scope = old_scope
    t.cur_generic_call_file_idx = old_file_idx
    t.cur_import_aliases = old_import_aliases.clone()
}

// build_generic_fn_decl_index (re)builds t.generic_fn_decl_index from every
// generic FnDecl across all files. Generic declarations never change during the
// fixpoint (monomorphize_pass only appends concrete clones), but the index maps
// keys to file indices, so it is rebuilt against the current file set.
fn (mut t Transformer) build_generic_fn_decl_index(files []ast.File) {
    t.generic_fn_decl_index = map[string]ast.FnDecl{}
    t.generic_call_candidate_names = map[string]bool{}
    mut dummy_owner := map[string]int{}
    for fi, file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl {
                if decl_generic_param_names(stmt).len == 0 {
                    continue
                }
                t.index_generic_fn_decl_for_monomorphize(mut dummy_owner, mut
                    t.generic_fn_decl_index, stmt, fi, file.mod)
            }
        }
    }
    for key, _ in t.generic_fn_decl_index {
        t.register_generic_call_candidate_name(key)
    }
    for name, _ in t.generic_fn_value_names {
        t.register_generic_call_candidate_name(name)
    }
}

fn (mut t Transformer) build_generic_fn_decl_index_from_flat(flat &ast.FlatAst, extra_stmts map[int][]ast.Stmt) {
    t.generic_fn_decl_index = map[string]ast.FnDecl{}
    t.generic_call_candidate_names = map[string]bool{}
    mut dummy_owner := map[string]int{}
    for fi in 0 .. flat.files.len {
        module_name := flat.file_mod(flat.files[fi])
        stmts := flat.file_cursor(fi).stmts()
        for si in 0 .. stmts.len() {
            stmt_c := stmts.at(si)
            if stmt_c.kind() != .stmt_fn_decl {
                continue
            }
            stmt := stmt_c.fn_decl_signature()
            if decl_generic_param_names(stmt).len == 0 {
                continue
            }
            t.index_generic_fn_decl_for_monomorphize(mut dummy_owner, mut t.generic_fn_decl_index,
                stmt, fi, module_name)
        }
        extra := extra_stmts[fi] or { []ast.Stmt{} }
        for stmt in extra {
            if stmt !is ast.FnDecl {
                continue
            }
            decl := stmt as ast.FnDecl
            if decl_generic_param_names(decl).len == 0 {
                continue
            }
            t.index_generic_fn_decl_for_monomorphize(mut dummy_owner, mut t.generic_fn_decl_index,
                decl, fi, module_name)
        }
    }
    for key, _ in t.generic_fn_decl_index {
        t.register_generic_call_candidate_name(key)
    }
    for name, _ in t.generic_fn_value_names {
        t.register_generic_call_candidate_name(name)
    }
}

fn (mut t Transformer) register_generic_call_candidate_name(name string) {
    base := generic_base_name_without_specialization(name)
    if base == '' {
        return
    }
    t.generic_call_candidate_names[base] = true
    dot := base.last_index_u8(`.`)
    if dot >= 0 {
        if dot + 1 < base.len {
            t.generic_call_candidate_names[base[dot + 1..]] = true
        }
    }
    dunder := last_double_underscore(base)
    if dunder >= 0 {
        if dunder + 2 < base.len {
            t.generic_call_candidate_names[base[dunder + 2..]] = true
        }
    }
}

fn (t &Transformer) may_target_generic_call_name(name string) bool {
    if name == '' {
        return false
    }
    base := generic_base_name_without_specialization(name)
    return base in t.generic_call_candidate_names
}

// collect_generic_call_specs_in_new_clones is the incremental counterpart of
// collect_generic_call_specs. After monomorphize_pass appends concrete clones,
// only those clones can introduce generic calls the previous scan did not see —
// every other statement is byte-for-byte unchanged and was already walked. So
// this rebuilds the generic-decl index (cheap, shallow) but deep-walks only the
// clones recorded in t.last_mono_clones, each under its owning file's module,
// scope and import context. For v2 self-host this replaces a full ~6s/~700MB
// rescan with a walk of a few dozen functions.
fn (mut t Transformer) collect_generic_call_specs_in_new_clones(files []ast.File) {
    if t.last_mono_clones.len == 0 {
        return
    }
    old_module := t.cur_module
    old_file := t.cur_file_name
    old_scope := t.scope
    old_file_idx := t.cur_generic_call_file_idx
    old_import_aliases := t.cur_import_aliases.clone()
    t.build_generic_fn_decl_index(files)
    for fi, file in files {
        if fi !in t.last_mono_clones {
            continue
        }
        clones := t.last_mono_clones[fi]
        if clones.len == 0 {
            continue
        }
        t.cur_file_name = file.name
        t.cur_module = file.mod
        t.cur_generic_call_file_idx = fi
        t.cur_import_aliases = import_aliases_for_generic_collect(file.imports)
        if scope := t.get_module_scope(file.mod) {
            t.scope = scope
        } else {
            t.scope = unsafe { nil }
        }
        for stmt in clones {
            t.collect_generic_call_specs_in_stmt(stmt)
        }
    }
    t.cur_module = old_module
    t.cur_file_name = old_file
    t.scope = old_scope
    t.cur_generic_call_file_idx = old_file_idx
    t.cur_import_aliases = old_import_aliases.clone()
}

fn (mut t Transformer) collect_generic_call_specs_in_new_clones_from_flat(flat &ast.FlatAst, extra_stmts map[int][]ast.Stmt) {
    if t.last_mono_clones.len == 0 {
        return
    }
    old_module := t.cur_module
    old_file := t.cur_file_name
    old_scope := t.scope
    old_file_idx := t.cur_generic_call_file_idx
    old_import_aliases := t.cur_import_aliases.clone()
    t.build_generic_fn_decl_index_from_flat(flat, extra_stmts)
    for fi in 0 .. flat.files.len {
        clones := t.last_mono_clones[fi] or { continue }
        if clones.len == 0 {
            continue
        }
        module_name := flat.file_mod(flat.files[fi])
        t.cur_file_name = flat.file_name(flat.files[fi])
        t.cur_module = module_name
        t.cur_generic_call_file_idx = fi
        t.cur_import_aliases = flat_import_aliases_for_generic_collect(flat, fi)
        if scope := t.get_module_scope(module_name) {
            t.scope = scope
        } else {
            t.scope = unsafe { nil }
        }
        for stmt in clones {
            t.collect_generic_call_specs_in_stmt(stmt)
        }
    }
    t.cur_module = old_module
    t.cur_file_name = old_file
    t.scope = old_scope
    t.cur_generic_call_file_idx = old_file_idx
    t.cur_import_aliases = old_import_aliases.clone()
}

fn (mut t Transformer) collect_generic_call_specs_in_new_structs(files []ast.File) {
    if t.last_struct_clones.len == 0 {
        return
    }
    old_module := t.cur_module
    old_file := t.cur_file_name
    old_scope := t.scope
    old_file_idx := t.cur_generic_call_file_idx
    old_import_aliases := t.cur_import_aliases.clone()
    t.build_generic_fn_decl_index(files)
    for fi, file in files {
        clones := t.last_struct_clones[fi] or { continue }
        if clones.len == 0 {
            continue
        }
        t.cur_file_name = file.name
        t.cur_module = file.mod
        t.cur_generic_call_file_idx = fi
        t.cur_import_aliases = import_aliases_for_generic_collect(file.imports)
        if scope := t.get_module_scope(file.mod) {
            t.scope = scope
        } else {
            t.scope = unsafe { nil }
        }
        for stmt in clones {
            t.collect_generic_call_specs_in_stmt(stmt)
        }
    }
    t.cur_module = old_module
    t.cur_file_name = old_file
    t.scope = old_scope
    t.cur_generic_call_file_idx = old_file_idx
    t.cur_import_aliases = old_import_aliases.clone()
}

fn (mut t Transformer) collect_generic_call_specs_in_new_structs_from_flat(flat &ast.FlatAst, extra_stmts map[int][]ast.Stmt) {
    if t.last_struct_clones.len == 0 {
        return
    }
    old_module := t.cur_module
    old_file := t.cur_file_name
    old_scope := t.scope
    old_file_idx := t.cur_generic_call_file_idx
    old_import_aliases := t.cur_import_aliases.clone()
    t.build_generic_fn_decl_index_from_flat(flat, extra_stmts)
    for fi in 0 .. flat.files.len {
        clones := t.last_struct_clones[fi] or { continue }
        if clones.len == 0 {
            continue
        }
        module_name := flat.file_mod(flat.files[fi])
        t.cur_file_name = flat.file_name(flat.files[fi])
        t.cur_module = module_name
        t.cur_generic_call_file_idx = fi
        t.cur_import_aliases = flat_import_aliases_for_generic_collect(flat, fi)
        if scope := t.get_module_scope(module_name) {
            t.scope = scope
        } else {
            t.scope = unsafe { nil }
        }
        for stmt in clones {
            t.collect_generic_call_specs_in_stmt(stmt)
        }
    }
    t.cur_module = old_module
    t.cur_file_name = old_file
    t.scope = old_scope
    t.cur_generic_call_file_idx = old_file_idx
    t.cur_import_aliases = old_import_aliases.clone()
}

fn import_aliases_for_generic_collect(imports []ast.ImportStmt) map[string]string {
    mut aliases := map[string]string{}
    for imp in imports {
        alias := if imp.alias != '' { imp.alias } else { imp.name.all_after_last('.') }
        if alias == '' || imp.name == '' {
            continue
        }
        aliases[alias] = imp.name
    }
    return aliases
}

fn flat_import_aliases_for_generic_collect(flat &ast.FlatAst, fi int) map[string]string {
    if fi < 0 || fi >= flat.files.len {
        return map[string]string{}
    }
    imports := flat.file_cursor(fi).imports()
    mut aliases := map[string]string{}
    for i in 0 .. imports.len() {
        imp := imports.at(i)
        if imp.kind() != .stmt_import {
            continue
        }
        name := imp.name()
        alias := if imp.extra_str() != '' { imp.extra_str() } else { name.all_after_last('.') }
        if alias == '' || name == '' {
            continue
        }
        aliases[alias] = name
    }
    return aliases
}

fn flat_file_struct_decls_with_extra(flat &ast.FlatAst, extra_stmts map[int][]ast.Stmt, fi int) []ast.StructDecl {
    if fi < 0 || fi >= flat.files.len {
        return []ast.StructDecl{}
    }
    stmt_cursors := flat.file_cursor(fi).stmts()
    extra := extra_stmts[fi] or { []ast.Stmt{} }
    mut decls := []ast.StructDecl{cap: stmt_cursors.len() + extra.len}
    for i in 0 .. stmt_cursors.len() {
        stmt_c := stmt_cursors.at(i)
        if stmt_c.kind() == .stmt_struct_decl {
            decls << stmt_c.struct_decl()
        }
    }
    for stmt in extra {
        if stmt is ast.StructDecl {
            decls << stmt
        }
    }
    return decls
}

fn append_flat_extra_stmts(mut extra_stmts map[int][]ast.Stmt, fi int, stmts []ast.Stmt) {
    if stmts.len == 0 {
        return
    }
    mut bucket := extra_stmts[fi] or { []ast.Stmt{} }
    bucket << stmts
    extra_stmts[fi] = bucket
}

fn (mut t Transformer) collect_generic_call_specs_in_stmts(stmts []ast.Stmt) {
    for stmt in stmts {
        t.collect_generic_call_specs_in_stmt(stmt)
    }
}

fn (mut t Transformer) collect_generic_call_specs_in_cursor_list(stmts ast.CursorList) {
    for i in 0 .. stmts.len() {
        t.collect_generic_call_specs_in_stmt_cursor(stmts.at(i))
    }
}

fn (mut t Transformer) collect_generic_call_specs_in_stmt_cursor(stmt ast.Cursor) {
    if !stmt.is_valid() {
        return
    }
    match stmt.kind() {
        .stmt_assert {
            t.collect_generic_call_specs_in_expr_cursor(stmt.edge(0))
            t.collect_generic_call_specs_in_expr_cursor(stmt.edge(1))
        }
        .stmt_assign {
            lhs_len := stmt.extra_int()
            for i in 0 .. lhs_len {
                t.collect_generic_call_specs_in_expr_cursor(stmt.edge(i))
            }
            for i in lhs_len .. stmt.edge_count() {
                t.collect_generic_call_specs_in_expr_cursor(stmt.edge(i))
            }
            t.collect_generic_scan_decl_assign_types_cursor(stmt)
        }
        .stmt_block {
            for i in 0 .. stmt.edge_count() {
                t.collect_generic_call_specs_in_stmt_cursor(stmt.edge(i))
            }
        }
        .stmt_comptime {
            t.collect_generic_call_specs_in_stmt_cursor(stmt.edge(0))
        }
        .stmt_const_decl {
            fields := stmt.list_at(0)
            for i in 0 .. fields.len() {
                t.collect_generic_call_specs_in_expr_cursor(fields.at(i).edge(0))
            }
        }
        .stmt_defer {
            for i in 0 .. stmt.edge_count() {
                t.collect_generic_call_specs_in_stmt_cursor(stmt.edge(i))
            }
        }
        .stmt_enum_decl {
            fields := stmt.list_at(2)
            for i in 0 .. fields.len() {
                t.collect_generic_call_specs_in_expr_cursor(fields.at(i).edge(1))
            }
        }
        .stmt_expr {
            t.collect_generic_call_specs_in_expr_cursor(stmt.edge(0))
        }
        .stmt_for_in {
            t.collect_generic_call_specs_in_expr_cursor(stmt.edge(0))
            t.collect_generic_call_specs_in_expr_cursor(stmt.edge(1))
            t.collect_generic_call_specs_in_expr_cursor(stmt.edge(2))
        }
        .stmt_for {
            init := stmt.edge(0)
            if init.kind() == .stmt_for_in {
                t.collect_generic_call_specs_in_for_stmt_cursor(stmt, init)
                return
            }
            t.collect_generic_call_specs_in_stmt_cursor(init)
            t.collect_generic_call_specs_in_expr_cursor(stmt.edge(1))
            t.collect_generic_call_specs_in_stmt_cursor(stmt.edge(2))
            for i in 3 .. stmt.edge_count() {
                t.collect_generic_call_specs_in_stmt_cursor(stmt.edge(i))
            }
        }
        .stmt_fn_decl {
            signature := stmt.fn_decl_signature()
            if decl_generic_param_names(signature).len == 0 {
                t.collect_generic_call_specs_in_fn_decl_cursor(stmt, signature)
            }
        }
        .stmt_global_decl {
            fields := stmt.list_at(1)
            for i in 0 .. fields.len() {
                t.collect_generic_call_specs_in_expr_cursor(fields.at(i).edge(1))
            }
        }
        .stmt_import, .stmt_module {}
        .stmt_return {
            for i in 0 .. stmt.edge_count() {
                t.collect_generic_call_specs_in_expr_cursor(stmt.edge(i))
            }
        }
        .stmt_struct_decl {
            fields := stmt.list_at(4)
            for i in 0 .. fields.len() {
                field := fields.at(i)
                t.collect_generic_call_specs_in_expr_cursor(field.edge(0))
                t.collect_generic_call_specs_in_expr_cursor(field.edge(1))
            }
            embedded := stmt.list_at(2)
            for i in 0 .. embedded.len() {
                t.collect_generic_call_specs_in_expr_cursor(embedded.at(i))
            }
            implemented := stmt.list_at(1)
            for i in 0 .. implemented.len() {
                t.collect_generic_call_specs_in_expr_cursor(implemented.at(i))
            }
        }
        else {}
    }
}

fn (mut t Transformer) collect_generic_call_specs_in_stmt(stmt ast.Stmt) {
    match stmt {
        ast.AssertStmt {
            t.collect_generic_call_specs_in_expr(stmt.expr)
            t.collect_generic_call_specs_in_expr(stmt.extra)
        }
        ast.AssignStmt {
            for expr in stmt.lhs {
                t.collect_generic_call_specs_in_expr(expr)
            }
            for expr in stmt.rhs {
                t.collect_generic_call_specs_in_expr(expr)
            }
            t.collect_generic_scan_decl_assign_types(stmt)
        }
        ast.BlockStmt {
            t.collect_generic_call_specs_in_stmts(stmt.stmts)
        }
        ast.ComptimeStmt {
            t.collect_generic_call_specs_in_stmt(stmt.stmt)
        }
        ast.ConstDecl {
            for field in stmt.fields {
                t.collect_generic_call_specs_in_expr(field.value)
            }
        }
        ast.DeferStmt {
            t.collect_generic_call_specs_in_stmts(stmt.stmts)
        }
        ast.EnumDecl {
            for field in stmt.fields {
                t.collect_generic_call_specs_in_expr(field.value)
            }
        }
        ast.ExprStmt {
            t.collect_generic_call_specs_in_expr(stmt.expr)
        }
        ast.ForInStmt {
            t.collect_generic_call_specs_in_expr(stmt.key)
            t.collect_generic_call_specs_in_expr(stmt.value)
            t.collect_generic_call_specs_in_expr(stmt.expr)
        }
        ast.ForStmt {
            if stmt.init is ast.ForInStmt {
                t.collect_generic_call_specs_in_for_stmt(stmt, stmt.init as ast.ForInStmt)
                return
            }
            t.collect_generic_call_specs_in_stmt(stmt.init)
            t.collect_generic_call_specs_in_expr(stmt.cond)
            t.collect_generic_call_specs_in_stmt(stmt.post)
            t.collect_generic_call_specs_in_stmts(stmt.stmts)
        }
        ast.FnDecl {
            if decl_generic_param_names(stmt).len == 0 {
                t.collect_generic_call_specs_in_fn_decl(stmt)
            }
        }
        ast.GlobalDecl {
            for field in stmt.fields {
                t.collect_generic_call_specs_in_expr(field.value)
            }
        }
        ast.ImportStmt {}
        ast.ModuleStmt {}
        ast.ReturnStmt {
            for expr in stmt.exprs {
                t.collect_generic_call_specs_in_expr(expr)
            }
        }
        ast.StructDecl {
            for field in stmt.fields {
                t.collect_generic_call_specs_in_expr(field.typ)
                t.collect_generic_call_specs_in_expr(field.value)
            }
            for embedded in stmt.embedded {
                t.collect_generic_call_specs_in_expr(embedded)
            }
            for implemented in stmt.implements {
                t.collect_generic_call_specs_in_expr(implemented)
            }
        }
        else {}
    }
}

fn (mut t Transformer) collect_generic_call_specs_in_for_stmt_cursor(stmt ast.Cursor, for_in ast.Cursor) {
    t.collect_generic_call_specs_in_expr_cursor(for_in.edge(0))
    t.collect_generic_call_specs_in_expr_cursor(for_in.edge(1))
    t.collect_generic_call_specs_in_expr_cursor(for_in.edge(2))
    t.collect_generic_call_specs_in_expr_cursor(stmt.edge(1))
    t.collect_generic_call_specs_in_stmt_cursor(stmt.edge(2))
    old_local_decl_types := t.local_decl_types.clone()
    t.seed_generic_scan_for_in_var_types_cursor(for_in)
    for i in 3 .. stmt.edge_count() {
        t.collect_generic_call_specs_in_stmt_cursor(stmt.edge(i))
    }
    t.local_decl_types = old_local_decl_types.clone()
}

fn (mut t Transformer) collect_generic_call_specs_in_for_stmt(stmt ast.ForStmt, for_in ast.ForInStmt) {
    t.collect_generic_call_specs_in_expr(for_in.key)
    t.collect_generic_call_specs_in_expr(for_in.value)
    t.collect_generic_call_specs_in_expr(for_in.expr)
    t.collect_generic_call_specs_in_expr(stmt.cond)
    t.collect_generic_call_specs_in_stmt(stmt.post)
    old_local_decl_types := t.local_decl_types.clone()
    t.seed_generic_scan_for_in_var_types(for_in)
    t.collect_generic_call_specs_in_stmts(stmt.stmts)
    t.local_decl_types = old_local_decl_types.clone()
}

fn (mut t Transformer) seed_generic