// 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.
// vtest build: !windows
module transformer

import os
import v2.ast
import v2.parser
import v2.pref as vpref
import v2.token
import v2.types

fn mono_test_transformer() &Transformer {
    env := &types.Environment{}
    return &Transformer{
        pref:                        &vpref.Preferences{}
        env:                         unsafe { env }
        needed_clone_fns:            map[string]string{}
        needed_array_contains_fns:   map[string]ArrayMethodInfo{}
        needed_array_index_fns:      map[string]ArrayMethodInfo{}
        needed_array_last_index_fns: map[string]ArrayMethodInfo{}
    }
}

fn test_worker_clone_sees_sumtype_decl_variant_cache() {
    checked := mono_check_sources_for_test([
        MonoSource{
            rel:  'foo/box.v'
            code: '
module foo

pub struct Box[T] {
pub:
    value T
}
'
        },
        MonoSource{
            rel:  'main.v'
            code: '
module main

import foo as f

type ImportedValue = f.Box[int] | f.Box[string]
'
        },
    ])
    mut transformer := checked.trans
    transformer.pre_pass(checked.files)
    mut worker := transformer.new_worker_clone(1)
    expected := ['foo__Box_T_int', 'foo__Box_T_string']

    assert transformer.get_sum_type_variants('ImportedValue') == expected
    assert worker.get_sum_type_variants('ImportedValue') == expected
    worker.sum_type_decl_variant_names['WorkerOnly'] = ['Nope']
    assert 'WorkerOnly' !in transformer.sum_type_decl_variant_names

    flat := ast.flatten_files(checked.files)
    mut flat_transformer := Transformer.new_with_pref(checked.trans.env, checked.trans.pref)
    flat_transformer.pre_pass_from_flat(&flat)
    mut flat_worker := flat_transformer.new_worker_clone(2)

    assert flat_transformer.get_sum_type_variants('ImportedValue') == expected
    assert flat_worker.get_sum_type_variants('ImportedValue') == expected
    flat_worker.sum_type_decl_variant_names['WorkerOnly'] = ['Nope']
    assert 'WorkerOnly' !in flat_transformer.sum_type_decl_variant_names
}

fn test_get_expr_type_prefers_cloned_init_expr_type_over_stale_position_type() {
    mut env := types.Environment.new()
    pos := token.Pos{
        id: 7
    }
    env.set_expr_type(pos.id, types.Type(types.Struct{
        name: 'gitly__GitHubRepoInfo'
    }))
    mut t := mono_test_transformer()
    t.env = env
    t.cur_module = 'json2'
    mut config_scope := types.new_scope(unsafe { nil })
    config_scope.insert_type('Config', types.Type(types.Struct{
        name: 'config__Config'
    }))
    t.cached_scopes['config'] = config_scope
    expr := ast.Expr(ast.InitExpr{
        typ: ast.Expr(ast.SelectorExpr{
            lhs: ast.Expr(ast.Ident{
                name: 'config'
            })
            rhs: ast.Ident{
                name: 'Config'
            }
        })
        pos: pos
    })
    typ := t.get_expr_type(expr) or { panic('expected cloned init expression type') }
    assert typ.name() == 'config__Config'
}

// substitute_type: primitives

fn test_substitute_type_returns_same_type_when_bindings_empty() {
    original := types.Type(types.NamedType('T'))
    out := substitute_type(original, map[string]types.Type{})
    assert out.name() == 'T'
}

fn test_substitute_type_replaces_placeholder_named_type() {
    bindings := {
        'T': types.Type(types.int_)
    }
    out := substitute_type(types.Type(types.NamedType('T')), bindings)
    assert out.name() == 'int'
}

fn test_generic_bindings_from_method_call_args_skip_receiver_param() {
    mut t := mono_test_transformer()
    t.local_decl_types['file'] = types.Type(types.Struct{
        name: 'File'
    })
    info := CallFnInfo{
        param_types:                    [
            types.Type(types.Struct{
                name: 'Walker'
            }),
            types.Type(types.NamedType('T')),
        ]
        generic_param_names_by_param:   ['', 'T']
        generic_param_indexes_by_param: [-1, 0]
        generic_params:                 ['T']
    }
    bindings := t.generic_bindings_from_call_args(info, [
        ast.Expr(ast.Ident{
            name: 'file'
        }),
    ]) or { panic('expected binding') }
    concrete := bindings['T'] or { panic('missing T binding') }
    assert concrete.name() == 'File'
}

fn test_generic_bindings_from_call_args_use_ast_direct_generic_metadata() {
    mut t := mono_test_transformer()
    t.local_decl_types['file'] = types.Type(types.Struct{
        name: 'File'
    })
    info := CallFnInfo{
        param_types:                    [
            types.Type(types.void_),
        ]
        generic_param_names_by_param:   ['T']
        generic_param_indexes_by_param: [0]
        generic_params:                 ['T']
    }
    bindings := t.generic_bindings_from_call_args(info, [
        ast.Expr(ast.Ident{
            name: 'file'
        }),
    ]) or { panic('expected binding from direct generic parameter metadata') }
    concrete := bindings['T'] or { panic('missing T binding') }
    assert concrete.name() == 'File'
}

fn test_generic_call_info_lookup_does_not_match_unrelated_short_name() {
    mut t := mono_test_transformer()
    t.generic_fn_decl_index['write'] = ast.FnDecl{
        name: 'write'
        typ:  ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'T'
                }),
            ]
        }
    }
    if _ := t.generic_fn_decl_for_call_info('v__Gen__write') {
        assert false, 'qualified non-generic methods must not resolve to unrelated generic functions'
    }
    if decl := t.generic_fn_decl_for_call_info('write') {
        assert decl.name == 'write'
    } else {
        assert false, 'expected exact generic function lookup to work'
    }
}

fn test_resolve_monomorphize_decl_key_prefers_module_suffix_over_short_name() {
    t := mono_test_transformer()
    decl := ast.FnDecl{
        name: 'uniq'
    }
    decl_node := {
        'uniq':         decl
        'arrays__uniq': decl
    }
    resolved := t.resolve_monomorphize_decl_key('http__arrays__uniq', decl_node) or {
        panic('missing resolved key')
    }
    assert resolved == 'arrays__uniq'
}

fn test_resolve_monomorphize_decl_key_rejects_unrelated_short_name() {
    t := mono_test_transformer()
    decl := ast.FnDecl{
        name: 'encode'
    }
    decl_node := {
        'encode':        decl
        'json2__encode': decl
    }
    if _ := t.resolve_monomorphize_decl_key('base64__encode', decl_node) {
        assert false, 'qualified generic lookup must not fall back to unrelated short names'
    }
    if _ := t.resolve_monomorphize_decl_key('base64.encode', decl_node) {
        assert false, 'dotted generic lookup must not fall back to unrelated short names'
    }
}

fn test_generic_call_info_bare_lookup_stays_in_current_module() {
    mut t := mono_test_transformer()
    t.cur_module = 'cbor'
    json_decl := ast.FnDecl{
        name: 'encode'
        typ:  ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'JsonT'
                }),
            ]
        }
    }
    cbor_decl := ast.FnDecl{
        name: 'encode'
        typ:  ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'CborT'
                }),
            ]
        }
    }
    t.generic_fn_decl_index['encode'] = json_decl
    t.generic_fn_decl_index['json2__encode'] = json_decl
    t.generic_fn_decl_index['cbor__encode'] = cbor_decl
    decl := t.generic_fn_decl_for_call_info('encode') or { panic('missing current module decl') }
    gp := decl.typ.generic_params[0] as ast.Ident
    assert gp.name == 'CborT'
}

fn test_transformer_pointer_guards_accept_low_canonical_pointers() {
    assert sumtype_payload_word_is_valid(1, 0x10000)
    assert transformer_data_ptr_has_valid_address(0x10000)
    assert !sumtype_payload_word_is_valid(1, 0)
    assert !sumtype_payload_word_is_valid(1, 3)
}

fn mono_transform_dijkstra_shape_for_test() []ast.File {
    source_path := os.join_path(os.temp_dir(), 'v2_mono_dijkstra_shape_${os.getpid()}.v')
    os.write_file(source_path, '
module main

struct NODE {
mut:
    data int
    priority int
}

fn push_pq[T](mut prior_queue []T, data int, priority int) {
    _ = prior_queue
    _ = data
    _ = priority
}

fn updating_priority[T](mut prior_queue []T, search_data int, new_priority int) {
    _ = prior_queue
    _ = search_data
    _ = new_priority
}

fn departure_priority[T](mut prior_queue []T) int {
    _ = prior_queue
    return 0
}

fn all_adjacents[T](g [][]T, v int) []int {
    mut temp := []int{}
    for i in 0 .. g.len {
        if g[v][i] > 0 {
            temp << i
        }
    }
    return temp
}

fn print_solution[T](dist []T) {
    _ = dist
}

fn print_paths_dist[T](path []T, dist []T) {
    _ = path
    _ = dist
}

fn dijkstra(g [][]int, s int) {
    mut pq_queue := []NODE{}
    push_pq(mut pq_queue, s, 0)
    mut n := g.len
    mut dist := []int{len: n, init: -1}
    mut path := []int{len: n, init: -1}
    dist[s] = 0
    for pq_queue.len != 0 {
        mut v := departure_priority(mut pq_queue)
        mut adjs_of_v := all_adjacents(g, v)
        mut new_dist := 0
        for w in adjs_of_v {
            new_dist = dist[v] + g[v][w]
            if dist[w] == -1 {
                dist[w] = new_dist
                push_pq(mut pq_queue, w, dist[w])
                path[w] = v
            }
            if dist[w] > new_dist {
                dist[w] = new_dist
                updating_priority(mut pq_queue, w, dist[w])
                path[w] = v
            }
        }
    }
    print_solution(dist)
    print_paths_dist(path, dist)
}
') or {
        panic('failed to write temp source')
    }
    defer {
        os.rm(source_path) or {}
    }
    prefs := &vpref.Preferences{
        backend:     .x64
        no_parallel: true
    }
    mut file_set := token.FileSet.new()
    mut par := parser.Parser.new(prefs)
    files := par.parse_files([source_path], mut file_set)
    mut env := types.Environment.new()
    mut checker := types.Checker.new(prefs, file_set, env)
    checker.check_files(files)
    mut trans := Transformer.new_with_pref(env, prefs)
    return trans.transform_files(files)
}

fn mono_collect_call_names_from_expr(expr ast.Expr, mut names []string) {
    match expr {
        ast.ArrayInitExpr {
            for nested in expr.exprs {
                mono_collect_call_names_from_expr(nested, mut names)
            }
        }
        ast.CallExpr {
            if expr.lhs is ast.Ident {
                names << expr.lhs.name
            }
            mono_collect_call_names_from_expr(expr.lhs, mut names)
            for arg in expr.args {
                mono_collect_call_names_from_expr(arg, mut names)
            }
        }
        ast.IfExpr {
            mono_collect_call_names_from_expr(expr.cond, mut names)
            for stmt in expr.stmts {
                mono_collect_call_names_from_stmt(stmt, mut names)
            }
            mono_collect_call_names_from_expr(expr.else_expr, mut names)
        }
        ast.InfixExpr {
            mono_collect_call_names_from_expr(expr.lhs, mut names)
            mono_collect_call_names_from_expr(expr.rhs, mut names)
        }
        ast.MatchExpr {
            mono_collect_call_names_from_expr(expr.expr, mut names)
            for branch in expr.branches {
                for cond in branch.cond {
                    mono_collect_call_names_from_expr(cond, mut names)
                }
                for stmt in branch.stmts {
                    mono_collect_call_names_from_stmt(stmt, mut names)
                }
            }
        }
        ast.ModifierExpr {
            mono_collect_call_names_from_expr(expr.expr, mut names)
        }
        ast.OrExpr {
            mono_collect_call_names_from_expr(expr.expr, mut names)
            for stmt in expr.stmts {
                mono_collect_call_names_from_stmt(stmt, mut names)
            }
        }
        ast.ParenExpr {
            mono_collect_call_names_from_expr(expr.expr, mut names)
        }
        ast.PrefixExpr {
            mono_collect_call_names_from_expr(expr.expr, mut names)
        }
        ast.SelectorExpr {
            mono_collect_call_names_from_expr(expr.lhs, mut names)
        }
        ast.StringInterLiteral {
            for inter in expr.inters {
                mono_collect_call_names_from_expr(inter.expr, mut names)
                mono_collect_call_names_from_expr(inter.format_expr, mut names)
            }
        }
        else {}
    }
}

fn mono_collect_string_literals_from_expr(expr ast.Expr, mut values []string) {
    match expr {
        ast.ArrayInitExpr {
            for nested in expr.exprs {
                mono_collect_string_literals_from_expr(nested, mut values)
            }
        }
        ast.CallExpr {
            mono_collect_string_literals_from_expr(expr.lhs, mut values)
            for arg in expr.args {
                mono_collect_string_literals_from_expr(arg, mut values)
            }
        }
        ast.IfExpr {
            mono_collect_string_literals_from_expr(expr.cond, mut values)
            for stmt in expr.stmts {
                mono_collect_string_literals_from_stmt(stmt, mut values)
            }
            mono_collect_string_literals_from_expr(expr.else_expr, mut values)
        }
        ast.InfixExpr {
            mono_collect_string_literals_from_expr(expr.lhs, mut values)
            mono_collect_string_literals_from_expr(expr.rhs, mut values)
        }
        ast.ModifierExpr {
            mono_collect_string_literals_from_expr(expr.expr, mut values)
        }
        ast.OrExpr {
            mono_collect_string_literals_from_expr(expr.expr, mut values)
            for stmt in expr.stmts {
                mono_collect_string_literals_from_stmt(stmt, mut values)
            }
        }
        ast.ParenExpr {
            mono_collect_string_literals_from_expr(expr.expr, mut values)
        }
        ast.PrefixExpr {
            mono_collect_string_literals_from_expr(expr.expr, mut values)
        }
        ast.SelectorExpr {
            mono_collect_string_literals_from_expr(expr.lhs, mut values)
        }
        ast.StringInterLiteral {
            values << expr.values
            for inter in expr.inters {
                mono_collect_string_literals_from_expr(inter.expr, mut values)
                mono_collect_string_literals_from_expr(inter.format_expr, mut values)
            }
        }
        ast.StringLiteral {
            values << expr.value
        }
        else {}
    }
}

fn mono_collect_string_literals_from_stmt(stmt ast.Stmt, mut values []string) {
    match stmt {
        ast.AssignStmt {
            for expr in stmt.lhs {
                mono_collect_string_literals_from_expr(expr, mut values)
            }
            for expr in stmt.rhs {
                mono_collect_string_literals_from_expr(expr, mut values)
            }
        }
        ast.ExprStmt {
            mono_collect_string_literals_from_expr(stmt.expr, mut values)
        }
        ast.ForStmt {
            mono_collect_string_literals_from_expr(stmt.cond, mut values)
            for nested in stmt.stmts {
                mono_collect_string_literals_from_stmt(nested, mut values)
            }
        }
        ast.ReturnStmt {
            for expr in stmt.exprs {
                mono_collect_string_literals_from_expr(expr, mut values)
            }
        }
        else {}
    }
}

fn mono_collect_call_names_from_stmt(stmt ast.Stmt, mut names []string) {
    match stmt {
        ast.AssignStmt {
            for expr in stmt.rhs {
                mono_collect_call_names_from_expr(expr, mut names)
            }
        }
        ast.ExprStmt {
            mono_collect_call_names_from_expr(stmt.expr, mut names)
        }
        ast.ForStmt {
            mono_collect_call_names_from_expr(stmt.cond, mut names)
            for nested in stmt.stmts {
                mono_collect_call_names_from_stmt(nested, mut names)
            }
        }
        ast.ReturnStmt {
            for expr in stmt.exprs {
                mono_collect_call_names_from_expr(expr, mut names)
            }
        }
        else {}
    }
}

fn mono_call_names_for_fn(files []ast.File, fn_name string) []string {
    mut names := []string{}
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.name == fn_name {
                for nested in stmt.stmts {
                    mono_collect_call_names_from_stmt(nested, mut names)
                }
            }
        }
    }
    return names
}

fn mono_assign_rhs_for_var(files []ast.File, fn_name string, var_name string) ?ast.Expr {
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.name == fn_name {
                for nested in stmt.stmts {
                    if nested is ast.AssignStmt {
                        for i, lhs in nested.lhs {
                            if lhs is ast.Ident && lhs.name == var_name && i < nested.rhs.len {
                                return nested.rhs[i]
                            }
                        }
                    }
                }
            }
        }
    }
    return none
}

fn mono_init_field(init ast.InitExpr, field_name string) ?ast.Expr {
    for field in init.fields {
        if field.name == field_name {
            return field.value
        }
    }
    return none
}

fn mono_assert_init_ident_name(init ast.InitExpr, expected string) {
    assert init.typ is ast.Ident, 'expected InitExpr typ ${expected}, got ${init.typ}'
    assert (init.typ as ast.Ident).name == expected
}

fn mono_assert_basic_number_expr(expr ast.Expr, expected string) {
    assert expr is ast.BasicLiteral, 'expected number literal ${expected}, got ${expr}'
    lit := expr as ast.BasicLiteral
    assert lit.kind == token.Token.number
    assert lit.value == expected
}

fn mono_assert_sumtype_payload_memdup_expr(expr ast.Expr, expected_variant string) {
    assert expr is ast.CastExpr, 'expected voidptr payload cast for ${expected_variant}, got ${expr}'
    voidptr_cast := expr as ast.CastExpr
    assert voidptr_cast.typ is ast.Ident
    assert (voidptr_cast.typ as ast.Ident).name == 'voidptr'
    assert voidptr_cast.expr is ast.CallExpr, 'expected memdup payload call, got ${voidptr_cast.expr}'
    memdup_call := voidptr_cast.expr as ast.CallExpr
    assert memdup_call.lhs is ast.Ident
    assert (memdup_call.lhs as ast.Ident).name == 'memdup'
    assert memdup_call.args.len == 2, 'expected memdup payload and sizeof args, got ${memdup_call.args}'
    payload_ref := memdup_call.args[0]
    assert payload_ref is ast.PrefixExpr, 'expected memdup payload address, got ${payload_ref}'
    payload_prefix := payload_ref as ast.PrefixExpr
    assert payload_prefix.op == token.Token.amp
    assert payload_prefix.expr is ast.InitExpr, 'expected concrete variant init payload, got ${payload_prefix.expr}'
    payload_init := payload_prefix.expr as ast.InitExpr
    mono_assert_init_ident_name(payload_init, expected_variant)
    size_arg := memdup_call.args[1]
    assert size_arg is ast.KeywordOperator, 'expected sizeof payload arg, got ${size_arg}'
    size_op := size_arg as ast.KeywordOperator
    assert size_op.op == token.Token.key_sizeof
    assert size_op.exprs.len == 1
    assert size_op.exprs[0] is ast.Ident
    assert (size_op.exprs[0] as ast.Ident).name == expected_variant
}

fn mono_collect_tag_compare_rhs_from_expr(expr ast.Expr, mut values []ast.Expr) {
    match expr {
        ast.IfExpr {
            mono_collect_tag_compare_rhs_from_expr(expr.cond, mut values)
            for stmt in expr.stmts {
                mono_collect_tag_compare_rhs_from_stmt(stmt, mut values)
            }
            mono_collect_tag_compare_rhs_from_expr(expr.else_expr, mut values)
        }
        ast.InfixExpr {
            if expr.op == token.Token.eq && expr.lhs is ast.SelectorExpr {
                lhs := expr.lhs as ast.SelectorExpr
                if lhs.rhs.name == '_tag' {
                    values << expr.rhs
                }
            }
            mono_collect_tag_compare_rhs_from_expr(expr.lhs, mut values)
            mono_collect_tag_compare_rhs_from_expr(expr.rhs, mut values)
        }
        ast.ParenExpr {
            mono_collect_tag_compare_rhs_from_expr(expr.expr, mut values)
        }
        else {}
    }
}

fn mono_collect_tag_compare_rhs_from_stmt(stmt ast.Stmt, mut values []ast.Expr) {
    match stmt {
        ast.AssignStmt {
            for expr in stmt.rhs {
                mono_collect_tag_compare_rhs_from_expr(expr, mut values)
            }
        }
        ast.ExprStmt {
            mono_collect_tag_compare_rhs_from_expr(stmt.expr, mut values)
        }
        ast.ReturnStmt {
            for expr in stmt.exprs {
                mono_collect_tag_compare_rhs_from_expr(expr, mut values)
            }
        }
        else {}
    }
}

fn mono_collect_return_exprs_from_stmt(stmt ast.Stmt, mut exprs []ast.Expr) {
    match stmt {
        ast.BlockStmt {
            for nested in stmt.stmts {
                mono_collect_return_exprs_from_stmt(nested, mut exprs)
            }
        }
        ast.ExprStmt {
            mono_collect_return_exprs_from_expr(stmt.expr, mut exprs)
        }
        ast.ForStmt {
            for nested in stmt.stmts {
                mono_collect_return_exprs_from_stmt(nested, mut exprs)
            }
            mono_collect_return_exprs_from_stmt(stmt.init, mut exprs)
            mono_collect_return_exprs_from_stmt(stmt.post, mut exprs)
        }
        ast.ReturnStmt {
            exprs << stmt.exprs
        }
        else {}
    }
}

fn mono_collect_return_exprs_from_expr(expr ast.Expr, mut exprs []ast.Expr) {
    match expr {
        ast.IfExpr {
            for stmt in expr.stmts {
                mono_collect_return_exprs_from_stmt(stmt, mut exprs)
            }
            mono_collect_return_exprs_from_expr(expr.else_expr, mut exprs)
        }
        else {}
    }
}

fn mono_return_exprs_for_decl(decl ast.FnDecl) []ast.Expr {
    mut exprs := []ast.Expr{}
    for stmt in decl.stmts {
        mono_collect_return_exprs_from_stmt(stmt, mut exprs)
    }
    return exprs
}

fn mono_tag_compare_rhs_for_fn(files []ast.File, fn_name string) []ast.Expr {
    mut values := []ast.Expr{}
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.name == fn_name {
                for nested in stmt.stmts {
                    mono_collect_tag_compare_rhs_from_stmt(nested, mut values)
                }
            }
        }
    }
    return values
}

fn mono_tag_compare_rhs_for_decl(decl ast.FnDecl) []ast.Expr {
    mut values := []ast.Expr{}
    for stmt in decl.stmts {
        mono_collect_tag_compare_rhs_from_stmt(stmt, mut values)
    }
    return values
}

fn mono_has_fn(files []ast.File, fn_name string) bool {
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.name == fn_name {
                return true
            }
        }
    }
    return false
}

fn mono_fn_names(files []ast.File) []string {
    mut names := []string{}
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl {
                names << stmt.name
            }
        }
    }
    return names
}

fn mono_method_decl_by_receiver(files []ast.File, receiver_name string, method_name string) ?ast.FnDecl {
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.is_method && stmt.name == method_name {
                receiver := stmt.receiver.typ
                if receiver is ast.Ident && receiver.name == receiver_name {
                    return stmt
                }
            }
        }
    }
    return none
}

fn mono_fn_decl_by_name(files []ast.File, fn_name string) ?ast.FnDecl {
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.name == fn_name {
                return stmt
            }
        }
    }
    return none
}

fn mono_assert_method_clone_by_receiver(files []ast.File, receiver_name string, method_name string) ast.FnDecl {
    fn_names := mono_fn_names(files)
    decl := mono_method_decl_by_receiver(files, receiver_name, method_name) or {
        assert false, 'missing concrete method clone ${receiver_name}.${method_name}, got ${fn_names}'
        return ast.FnDecl{}
    }
    assert decl.is_method, '${receiver_name}.${method_name} must stay a method clone'
    assert decl.name == method_name
    assert decl.stmts.len > 0, '${receiver_name}.${method_name} must keep its cloned method body'
    return decl
}

fn mono_call_names_for_decl(decl ast.FnDecl) []string {
    mut names := []string{}
    for stmt in decl.stmts {
        mono_collect_call_names_from_stmt(stmt, mut names)
    }
    return names
}

fn mono_call_lhs_shape(expr ast.Expr) string {
    match expr {
        ast.GenericArgs {
            return 'GenericArgs(${mono_call_lhs_shape(expr.lhs)})'
        }
        ast.GenericArgOrIndexExpr {
            return 'GenericArgOrIndexExpr(${mono_call_lhs_shape(expr.lhs)})'
        }
        ast.Ident {
            return 'Ident(${expr.name})'
        }
        ast.IndexExpr {
            return 'IndexExpr(${mono_call_lhs_shape(expr.lhs)})'
        }
        ast.SelectorExpr {
            return 'Selector(${mono_call_lhs_shape(expr.lhs)}.${expr.rhs.name})'
        }
        else {
            return typeof(expr).name
        }
    }
}

fn mono_collect_call_lhs_shapes_from_expr(expr ast.Expr, mut shapes []string) {
    match expr {
        ast.CallExpr {
            shapes << mono_call_lhs_shape(expr.lhs)
            mono_collect_call_lhs_shapes_from_expr(expr.lhs, mut shapes)
            for arg in expr.args {
                mono_collect_call_lhs_shapes_from_expr(arg, mut shapes)
            }
        }
        ast.IfExpr {
            mono_collect_call_lhs_shapes_from_expr(expr.cond, mut shapes)
            for stmt in expr.stmts {
                mono_collect_call_lhs_shapes_from_stmt(stmt, mut shapes)
            }
            mono_collect_call_lhs_shapes_from_expr(expr.else_expr, mut shapes)
        }
        ast.InfixExpr {
            mono_collect_call_lhs_shapes_from_expr(expr.lhs, mut shapes)
            mono_collect_call_lhs_shapes_from_expr(expr.rhs, mut shapes)
        }
        ast.MatchExpr {
            mono_collect_call_lhs_shapes_from_expr(expr.expr, mut shapes)
            for branch in expr.branches {
                for cond in branch.cond {
                    mono_collect_call_lhs_shapes_from_expr(cond, mut shapes)
                }
                for stmt in branch.stmts {
                    mono_collect_call_lhs_shapes_from_stmt(stmt, mut shapes)
                }
            }
        }
        ast.ParenExpr {
            mono_collect_call_lhs_shapes_from_expr(expr.expr, mut shapes)
        }
        ast.PrefixExpr {
            mono_collect_call_lhs_shapes_from_expr(expr.expr, mut shapes)
        }
        ast.SelectorExpr {
            mono_collect_call_lhs_shapes_from_expr(expr.lhs, mut shapes)
        }
        else {}
    }
}

fn mono_collect_call_lhs_shapes_from_stmt(stmt ast.Stmt, mut shapes []string) {
    match stmt {
        ast.AssignStmt {
            for expr in stmt.rhs {
                mono_collect_call_lhs_shapes_from_expr(expr, mut shapes)
            }
        }
        ast.ExprStmt {
            mono_collect_call_lhs_shapes_from_expr(stmt.expr, mut shapes)
        }
        ast.ReturnStmt {
            for expr in stmt.exprs {
                mono_collect_call_lhs_shapes_from_expr(expr, mut shapes)
            }
        }
        else {}
    }
}

fn mono_call_lhs_shapes_for_decl(decl ast.FnDecl) []string {
    mut shapes := []string{}
    for stmt in decl.stmts {
        mono_collect_call_lhs_shapes_from_stmt(stmt, mut shapes)
    }
    return shapes
}

fn mono_raw_call_name(expr ast.Expr) string {
    match expr {
        ast.Ident {
            return expr.name
        }
        ast.SelectorExpr {
            return expr.rhs.name
        }
        else {
            return mono_call_lhs_shape(expr)
        }
    }
}

fn mono_collect_raw_call_names_from_expr(expr ast.Expr, mut names []string) {
    match expr {
        ast.CallExpr {
            names << mono_raw_call_name(expr.lhs)
            mono_collect_raw_call_names_from_expr(expr.lhs, mut names)
            for arg in expr.args {
                mono_collect_raw_call_names_from_expr(arg, mut names)
            }
        }
        ast.IfExpr {
            mono_collect_raw_call_names_from_expr(expr.cond, mut names)
            for stmt in expr.stmts {
                mono_collect_raw_call_names_from_stmt(stmt, mut names)
            }
            mono_collect_raw_call_names_from_expr(expr.else_expr, mut names)
        }
        ast.InfixExpr {
            mono_collect_raw_call_names_from_expr(expr.lhs, mut names)
            mono_collect_raw_call_names_from_expr(expr.rhs, mut names)
        }
        ast.MatchExpr {
            mono_collect_raw_call_names_from_expr(expr.expr, mut names)
            for branch in expr.branches {
                for cond in branch.cond {
                    mono_collect_raw_call_names_from_expr(cond, mut names)
                }
                for stmt in branch.stmts {
                    mono_collect_raw_call_names_from_stmt(stmt, mut names)
                }
            }
        }
        ast.ParenExpr {
            mono_collect_raw_call_names_from_expr(expr.expr, mut names)
        }
        ast.PrefixExpr {
            mono_collect_raw_call_names_from_expr(expr.expr, mut names)
        }
        ast.SelectorExpr {
            mono_collect_raw_call_names_from_expr(expr.lhs, mut names)
        }
        else {}
    }
}

fn mono_collect_raw_call_names_from_stmt(stmt ast.Stmt, mut names []string) {
    match stmt {
        ast.AssignStmt {
            for expr in stmt.rhs {
                mono_collect_raw_call_names_from_expr(expr, mut names)
            }
        }
        ast.ExprStmt {
            mono_collect_raw_call_names_from_expr(stmt.expr, mut names)
        }
        ast.ReturnStmt {
            for expr in stmt.exprs {
                mono_collect_raw_call_names_from_expr(expr, mut names)
            }
        }
        else {}
    }
}

fn mono_raw_call_names_for_decl(decl ast.FnDecl) []string {
    mut names := []string{}
    for stmt in decl.stmts {
        mono_collect_raw_call_names_from_stmt(stmt, mut names)
    }
    return names
}

fn mono_string_literals_for_decl(decl ast.FnDecl) []string {
    mut values := []string{}
    for stmt in decl.stmts {
        mono_collect_string_literals_from_stmt(stmt, mut values)
    }
    return values
}

fn mono_specs_summary(t &Transformer) string {
    mut keys := t.env.generic_types.keys()
    keys.sort()
    mut parts := []string{}
    for key in keys {
        bindings_list := t.env.generic_types[key] or { continue }
        mut sigs := []string{cap: bindings_list.len}
        for bindings in bindings_list {
            sigs << generic_bindings_signature(bindings)
        }
        sigs.sort()
        parts << '${key}=[${sigs.join(',')}]'
    }
    return parts.join(';')
}

fn mono_has_spec(t &Transformer, key string, sig string) bool {
    bindings_list := t.env.generic_types[key] or { return false }
    for bindings in bindings_list {
        if generic_bindings_signature(bindings) == sig {
            return true
        }
    }
    return false
}

fn mono_decl_label(decl ast.FnDecl) string {
    if decl.is_method && decl.receiver.typ is ast.Ident {
        return '${(decl.receiver.typ as ast.Ident).name}__${decl.name}'
    }
    return decl.name
}

fn mono_last_clone_names(t &Transformer) []string {
    mut names := []string{}
    for _, stmts in t.last_mono_clones {
        for stmt in stmts {
            if stmt is ast.FnDecl {
                names << mono_decl_label(stmt)
            }
        }
    }
    names.sort()
    return names
}

fn mono_last_clone_decl(t &Transformer, name string) ?ast.FnDecl {
    for _, stmts in t.last_mono_clones {
        for stmt in stmts {
            if stmt is ast.FnDecl && (stmt.name == name || mono_decl_label(stmt) == name) {
                return stmt
            }
        }
    }
    return none
}

fn mono_binding_lookup_summary(t &Transformer, keys []string) string {
    mut parts := []string{cap: keys.len}
    for key in keys {
        if bindings := t.lookup_monomorphized_fn_bindings('main', key) {
            parts << '${key}=${generic_bindings_signature(bindings)}'
        } else {
            parts << '${key}=none'
        }
    }
    return parts.join(';')
}

fn mono_assert_no_qualified_queue_array_string_fn_decl(fn_names []string, method_name string) {
    qualified := 'datatypes__Queue_T_Array_string__${method_name}'
    assert qualified !in fn_names, 'qualified method FnDecl should not be emitted for canonical clone: ${fn_names}'
}

fn mono_assert_no_open_queue_method_names(fn_names []string, call_names []string, method_name string) {
    short_open := 'Queue__${method_name}'
    qualified_open := 'datatypes__Queue__${method_name}'
    assert short_open !in fn_names, 'open Queue method FnDecl leaked into ${fn_names}'
    assert qualified_open !in fn_names, 'open datatypes Queue method FnDecl leaked into ${fn_names}'
    assert short_open !in call_names, 'open Queue method call leaked into ${call_names}'
    assert qualified_open !in call_names, 'open datatypes Queue method call leaked into ${call_names}'
}

fn mono_assert_no_open_queue_is_empty_names(fn_names []string, call_names []string) {
    mono_assert_no_open_queue_method_names(fn_names, call_names, 'is_empty')
}

fn mono_assert_specialized_inner_calls(call_names []string, expected string, open_names []string) {
    assert expected in call_names, 'expected specialized internal call ${expected}, got ${call_names}'
    for open_name in open_names {
        assert open_name !in call_names, 'open internal call ${open_name} leaked into ${call_names}'
    }
}

fn mono_assert_no_open_str_calls(call_names []string, open_names []string) {
    for open_name in open_names {
        assert open_name !in call_names, 'open str call ${open_name} leaked into ${call_names}'
    }
}

fn mono_assert_no_unresolved_generic_receiver_names(names []string, label string) {
    for name in names {
        assert !name.contains('unknown__'), '${label} leaked unresolved call ${name} in ${names}'
        assert !name.contains('_T_datatypes_T'), '${label} kept unresolved receiver generic ${name} in ${names}'
    }
}

struct MonoSource {
    rel  string
    code string
}

struct MonoCheckedSources {
    files []ast.File
    trans &Transformer
}

fn mono_nested_min_source() string {
    return '
module main

struct Empty {}

struct Node[T] {
    value T
    left  Tree[T]
    right Tree[T]
}

type Tree[T] = Empty | Node[T]

fn (tree Tree[T]) min[T]() T {
    return match tree {
        Empty { T(1e9) }
        Node[T] { tree.value }
    }
}

fn (tree Tree[T]) take_min[T]() T {
    return match tree {
        Empty { T(0) }
        Node[T] { tree.right.min() }
    }
}

fn use() f64 {
    empty := Tree[f64](Empty{})
    tree := Tree[f64](Node[f64]{1.0, empty, empty})
    return tree.take_min()
}
'
}

fn mono_insert_size_source() string {
    return '
module main

struct Empty {}

struct Node[T] {
    value T
    left  Tree[T]
    right Tree[T]
}

type Tree[T] = Empty | Node[T]

fn (tree Tree[T]) size[T]() int {
    return match tree {
        Empty { 0 }
        Node[T] { 1 + tree.left.size() + tree.right.size() }
    }
}

fn (tree Tree[T]) insert[T](x T) Tree[T] {
    return match tree {
        Empty { Node[T]{x, tree, tree} }
        Node[T] {
            if x == tree.value {
                tree
            } else if x < tree.value {
                Node[T]{
                    ...tree
                    left: tree.left.insert(x)
                }
            } else {
                Node[T]{
                    ...tree
                    right: tree.right.insert(x)
                }
            }
        }
    }
}

fn use() int {
    mut tree := Tree[f64](Empty{})
    tree = tree.insert(0.2)
    tree = tree.insert(0.5)
    return tree.size()
}
'
}

fn mono_transform_sources_for_test(sources []MonoSource) []ast.File {
    checked := mono_check_sources_for_test(sources)
    mut trans := checked.trans
    return trans.transform_files(checked.files)
}

fn mono_check_sources_for_test(sources []MonoSource) MonoCheckedSources {
    tmp_dir := os.join_path(os.temp_dir(), 'v2_mono_sources_${os.getpid()}')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    mut paths := []string{cap: sources.len}
    for source in sources {
        path := os.join_path(tmp_dir, source.rel)
        os.mkdir_all(os.dir(path)) or { panic(err) }
        os.write_file(path, source.code) or { panic('failed to write ${path}') }
        paths << path
    }
    prefs := &vpref.Preferences{
        backend:     .x64
        no_parallel: true
    }
    mut file_set := token.FileSet.new()
    mut par := parser.Parser.new(prefs)
    files := par.parse_files(paths, mut file_set)
    mut env := types.Environment.new()
    mut checker := types.Checker.new(prefs, file_set, env)
    checker.check_files(files)
    mut trans := Transformer.new_with_pref(env, prefs)
    return MonoCheckedSources{
        files: files
        trans: trans
    }
}

fn mono_transform_sources_flat_direct_for_test(sources []MonoSource) []ast.File {
    tmp_dir := os.join_path(os.temp_dir(), 'v2_mono_sources_flat_${os.getpid()}')
    os.rmdir_all(tmp_dir) or {}
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    mut paths := []string{cap: sources.len}
    for source in sources {
        path := os.join_path(tmp_dir, source.rel)
        os.mkdir_all(os.dir(path)) or { panic(err) }
        os.write_file(path, source.code) or { panic('failed to write ${path}') }
        paths << path
    }
    prefs := &vpref.Preferences{
        backend:     .x64
        no_parallel: true
    }
    mut file_set := token.FileSet.new()
    mut par := parser.Parser.new(prefs)
    files := par.parse_files(paths, mut file_set)
    mut env := types.Environment.new()
    mut checker := types.Checker.new(prefs, file_set, env)
    checker.check_files(files)
    flat := ast.flatten_files(files)
    mut trans := Transformer.new_with_pref(env, prefs)
    return trans.transform_flat_to_flat_direct(&flat, []).to_files()
}

fn test_imported_generic_struct_init_receiver_method_call_is_monomorphized() {
    files := mono_transform_sources_for_test([
        MonoSource{
            rel:  'datatypes/queue.v'
            code: '
module datatypes

pub struct Queue[T] {
mut:
    elements []T
}

pub fn (mut queue Queue[T]) push(value T) {
    queue.elements << value
}

pub fn (queue Queue[T]) is_empty() bool {
    return queue.elements.len == 0
}

pub fn (mut queue Queue[T]) pop() !T {
    return queue.elements[0]
}
'
        },
        MonoSource{
            rel:  'main.v'
            code: '
module main

import datatypes

fn use(value []string) bool {
    mut queue := datatypes.Queue[[]string]{}
    queue.push(value)
    if queue.is_empty() {
        return false
    }
    popped := queue.pop() or { return false }
    return popped.len == 1
}
'
        },
    ])
    fn_names := mono_fn_names(files)
    call_names := mono_call_names_for_fn(files, 'use')
    mono_assert_method_clone_by_receiver(files, 'Queue_T_Array_string', 'push')
    mono_assert_method_clone_by_receiver(files, 'Queue_T_Array_string', 'is_empty')
    mono_assert_method_clone_by_receiver(files, 'Queue_T_Array_string', 'pop')
    mono_assert_no_qualified_queue_array_string_fn_decl(fn_names, 'push')
    mono_assert_no_qualified_queue_array_string_fn_decl(fn_names, 'is_empty')
    mono_assert_no_qualified_queue_array_string_fn_decl(fn_names, 'pop')
    assert call_names == [
        'datatypes__Queue_T_Array_string__push',
        'datatypes__Queue_T_Array_string__is_empty',
        'datatypes__Queue_T_Array_string__pop',
    ], 'expected exact imported Queue[[]string] method calls, got ${call_names}'
    mono_assert_no_open_queue_method_names(fn_names, call_names, 'push')
    mono_assert_no_open_queue_is_empty_names(fn_names, call_names)
    mono_assert_no_open_queue_method_names(fn_names, call_names, 'pop')
}

fn test_imported_generic_method_clone_body_rewrites_nested_receiver_calls() {
    files := mono_transform_sources_for_test([
        MonoSource{
            rel:  'datatypes/inner.v'
            code: '
module datatypes

pub struct Inner[T] {
mut:
    values []T
}

pub fn (inner Inner[T]) is_empty() bool {
    return inner.values.len == 0
}

pub fn (mut inner Inner[T]) shift() !T {
    return inner.values[0]
}
'
        },
        MonoSource{
            rel:  'datatypes/outer.v'
            code: '
module datatypes

pub struct Outer[T] {
mut:
    inner Inner[T]
}

pub fn (outer Outer[T]) is_empty() bool {
    return outer.inner.is_empty()
}

pub fn (mut outer Outer[T]) pop() !T {
    return outer.inner.shift()
}
'
        },
        MonoSource{
            rel:  'main.v'
            code: '
module main

import datatypes

fn use() bool {
    mut outer := datatypes.Outer[[]string]{}
    if outer.is_empty() {
        return false
    }
    popped := outer.pop() or { return false }
    return popped.len == 1
}
'
        },
    ])
    fn_names := mono_fn_names(files)
    call_names := mono_call_names_for_fn(files, 'use')
    outer_is_empty := mono_assert_method_clone_by_receiver(files, 'Outer_T_Array_string',
        'is_empty')
    outer_pop := mono_assert_method_clone_by_receiver(files, 'Outer_T_Array_string', 'pop')
    mono_assert_method_clone_by_receiver(files, 'Inner_T_Array_string', 'is_empty')
    mono_assert_method_clone_by_receiver(files, 'Inner_T_Array_string', 'shift')
    assert call_names == [
        'datatypes__Outer_T_Array_string__is_empty',
        'datatypes__Outer_T_Array_string__pop',
    ], 'expected exact imported Outer[[]string] method calls, got ${call_names}'
    assert 'datatypes__Outer__is_empty' !in call_names
    assert 'datatypes__Outer__pop' !in call_names
    assert 'Outer__is_empty' !in call_names
    assert 'Outer__pop' !in call_names
    assert 'datatypes__Outer_T_Array_string__is_empty' !in fn_names
    assert 'datatypes__Outer_T_Array_string__pop' !in fn_names
    is_empty_body_calls := mono_call_names_for_decl(outer_is_empty)
    pop_body_calls := mono_call_names_for_decl(outer_pop)
    mono_assert_specialized_inner_calls(is_empty_body_calls,
        'datatypes__Inner_T_Array_string__is_empty', [
        'datatypes__Inner__is_empty',
        'Inner__is_empty',
    ])
    mono_assert_specialized_inner_calls(pop_body_calls, 'datatypes__Inner_T_Array_string__shift', [
        'datatypes__Inner__shift',
        'Inner__shift',
    ])
}

fn test_local_generic_struct_init_receiver_method_call_is_monomorphized() {
    files := mono_transform_sources_for_test([
        MonoSource{
            rel:  'main.v'
            code: '
module main

struct Queue[T] {
mut:
    elements []T
}

fn (queue Queue[T]) is_empty() bool {
    return queue.elements.len == 0
}

fn use() bool {
    mut queue := Queue[[]string]{}
    return queue.is_empty()
}
'
        },
    ])
    fn_names := mono_fn_names(files)
    call_names := mono_call_names_for_fn(files, 'use')
    mono_assert_method_clone_by_receiver(files, 'Queue_T_Array_string', 'is_empty')
    assert call_names == ['Queue_T_Array_string__is_empty'], 'expected exact local Queue[[]string].is_empty call, got ${call_names}'
    mono_assert_no_open_queue_is_empty_names(fn_names, call_names)
}

fn test_generic_sumtype_cast_init_does_not_lower_to_open_call() {
    files := mono_transform_sources_for_test([
        MonoSource{
            rel:  'main.v'
            code: '
module main

struct Empty {}

struct Node[T] {
    value T
}

type Tree[T] = Empty | Node[T]

fn use() {
    tree := Tree[f64](Empty{})
    _ = tree
}
'
        },
    ])
    call_names := mono_call_names_for_fn(files, 'use')
    tree_rhs := mono_assign_rhs_for_var(files, 'use', 'tree') or {
        assert false, 'missing transformed tree assignment'
        return
    }
    assert tree_rhs is ast.InitExpr, 'generic sumtype cast should lower to InitExpr, got ${typeof(tree_rhs).name}'
    tree_init := tree_rhs as ast.InitExpr
    mono_assert_init_ident_name(tree_init, 'Tree_T_f64')
    tag_value := mono_init_field(tree_init, '_tag') or {
        assert false, 'missing Tree_T_f64 _tag field in ${tree_init.fields}'
        return
    }
    mono_assert_basic_number_expr(tag_value, '0')
    assert call_names == [], 'generic sumtype cast should lower to a wrapper, got calls ${call_names}'
    assert 'Tree_T_f64' !in call_names
}

fn test_generic_sumtype_concrete_variant_wrap_does_not_lower_to_open_call() {
    files := mono_transform_sources_for_test([
        MonoSource{
            rel:  'main.v'
            code: '
module main

struct Empty {}

struct Node[T] {
    value T
    left  Tree[T]
    right Tree[T]
}

type Tree[T] = Empty | Node[T]

fn use() {
    empty := Tree[f64](Empty{})
    tree := Tree[f64](Node[f64]{1.0, empty, empty})
    _ = tree
}
'
        },
    ])
    call_names := mono_call_names_for_fn(files, 'use')
    tree_rhs := mono_assign_rhs_for_var(files, 'use', 'tree') or {
        assert false, 'missing transformed tree assignment'
        return
    }
    assert tree_rhs is ast.InitExpr, 'generic sumtype variant cast should lower to InitExpr, got ${typeof(tree_rhs).name}'
    tree_init := tree_rhs as ast.InitExpr
    mono_assert_init_ident_name(tree_init, 'Tree_T_f64')
    tag_value := mono_init_field(tree_init, '_tag') or {
        assert false, 'missing Tree_T_f64 _tag field in ${tree_init.fields}'
        return
    }
    mono_assert_basic_number_expr(tag_value, '1')
    payload_value := mono_init_field(tree_init, '_data._Node_T_f64') or {
        assert false, 'missing Tree_T_f64 Node_T_f64 payload field in ${tree_init.fields}'
        return
    }
    mono_assert_sumtype_payload_memdup_expr(payload_value, 'Node_T_f64')
    assert 'Tree_T_f64' !in call_names, 'generic sumtype cast leaked callable Tree_T_f64 in ${call_names}'
    assert 'Tree' !in call_names, 'generic sumtype cast leaked callable Tree in ${call_names}'
    for name in call_names {
        assert !name.contains('Tree_T_T'), 'generic sumtype cast leaked open generic name ${name} in ${call_names}'
    }
}

fn test_non_generic_concrete_sumtype_return_wraps_variant() {
    files := mono_transform_sources_for_test([
        MonoSource{
            rel:  'main.v'
            code: '
module main

struct Empty {}

struct Node[T] {
    value T
}

type Tree[T] = Empty | Node[T]

fn make() Tree[int] {
    return Node[int]{value: 7}
}
'
        },
    ])
    make_decl := mono_fn_decl_by_name(files, 'make') or {
        assert false, 'missing transformed make function'
        return
    }
    returns := mono_return_exprs_for_decl(make_decl)
    assert returns.len == 1, 'expected one make return, got ${returns}'
    ret_expr := returns[0]
    assert ret_expr is ast.InitExpr, 'Tree[int] return should wrap Node[int], got ${ret_expr}'
    ret_init := ret_expr as ast.InitExpr
    mono_assert_init_ident_name(ret_init, 'Tree_T_int')
    tag_value := mono_init_field(ret_init, '_tag') or {
        assert false, 'missing Tree_T_int _tag field in ${ret_init.fields}'
        return
    }
    mono_assert_basic_number_expr(tag_value, '1')
    payload_value := mono_init_field(ret_init, '_data._Node_T_int') or {
        assert false, 'missing Tree_T_int Node_T_int payload field in ${ret_init.fields}'
        return
    }
    mono_assert_sumtype_payload_memdup_expr(payload_value, 'Node_T_int')
}

fn test_nested_module_concrete_generic_sumtype_base_does_not_fall_back_to_local_tree() {
    nested_tree_type := types.Type(types.SumType{
        name:           'foo.bar__Tree'
        generic_params: ['T']
        variants:       [
            types.Type(types.Struct{
                name: 'foo.bar__Empty'
            }),
            types.Type(types.Struct{
                name:           'foo.bar__Node'
                generic_params: ['T']
            }),
        ]
    })
    local_tree_type := types.Type(types.SumType{
        name:           'main__Tree'
        generic_params: ['T']
        variants:       [
            types.Type(types.Struct{
                name: 'main__Wrong'
            }),
        ]
    })
    foo_tree_type := types.Type(types.SumType{
        name:           'foo__Tree'
        generic_params: ['T']
        variants:       [
            types.Type(types.Struct{
                name: 'foo__Wrong'
            }),
        ]
    })
    mut nested_scope := types.new_scope(unsafe { nil })
    nested_scope.insert_type('Tree', nested_tree_type)
    mut foo_scope := types.new_scope(unsafe { nil })
    foo_scope.insert_type('Tree', foo_tree_type)
    mut main_scope := types.new_scope(unsafe { nil })
    main_scope.insert_type('Tree', local_tree_type)
    mut t := mono_test_transformer()
    t.cur_module = 'main'
    t.cached_scopes = {
        'foo.bar': nested_scope
        'foo':     foo_scope
        'main':    main_scope
    }
    t.cur_monomorphized_fn_bindings = {
        'T': types.Type(types.int_)
    }

    base := t.concrete_generic_sumtype_base_type('foo__bar__Tree_T_int') or {
        assert false, 'missing nested foo.bar Tree base'
        return
    }
    assert base is types.SumType
    assert (base as types.SumType).name == 'foo.bar__Tree'
    info := t.sumtype_wrap_info_for_name('foo__bar__Tree_T_int') or {
        assert false, 'missing nested foo.bar Tree wrap info'
        return
    }
    assert info.name == 'foo__bar__Tree_T_int'
    assert info.variants == ['foo__bar__Empty', 'foo__bar__Node_T_int']
    assert 'foo__Wrong_T_int' !in info.variants
    assert 'main__Wrong_T_int' !in info.variants
}

fn test_leaf_module_concrete_generic_sumtype_base_fallback_beats_parent_module_tree() {
    bar_tree_type := types.Type(types.SumType{
        name:           'bar__Tree'
        generic_params: ['T']
        variants:       [
            types.Type(types.Struct{
                name: 'bar__Empty'
            }),
            types.Type(types.Struct{
                name:           'bar__Node'
                generic_params: ['T']
            }),
        ]
    })
    foo_tree_type := types.Type(types.SumType{
        name:           'foo__Tree'
        generic_params: ['T']
        variants:       [
            types.Type(types.Struct{
                name: 'foo__Wrong'
            }),
        ]
    })
    mut bar_scope := types.new_scope(unsafe { nil })
    bar_scope.insert_type('Tree', bar_tree_type)
    mut foo_scope := types.new_scope(unsafe { nil })
    foo_scope.insert_type('Tree', foo_tree_type)
    mut t := mono_test_transformer()
    t.cur_module = 'main'
    t.cached_scopes = {
        'bar': bar_scope
        'foo': foo_scope
    }
    t.cur_monomorphized_fn_bindings = {
        'T': types.Type(types.int_)
    }

    base := t.concrete_generic_sumtype_base_type('foo__bar__Tree_T_int') or {
        assert false, 'missing leaf module bar Tree base'
        return
    }
    assert base is types.SumType
    assert (base as types.SumType).name == 'bar__Tree'
    info := t.sumtype_wrap_info_for_name('foo__bar__Tree_T_int') or {
        assert false, 'missing leaf module bar Tree wrap info'
        return
    }
    assert info.name == 'foo__bar__Tree_T_int'
    assert info.variants == ['bar__Empty', 'bar__Node_T_int']
    assert 'foo__Wrong_T_int' !in info.variants
}

fn test_option_concrete_sumtype_return_wraps_variant() {
    files := mono_transform_sources_for_test([
        MonoSource{
            rel:  'main.v'
            code: '
module main

struct Empty {}

struct Node[T] {
    value T
}

type Tree[T] = Empty | Node[T]

fn make() ?Tree[int] {
    return Node[int]{value: 7}
}
'
        },
    ])
    make_decl := mono_fn_decl_by_name(files, 'make') or {
        assert false, 'missing transformed make function'
        return
    }
    returns := mono_return_exprs_for_decl(make_decl)
    assert returns.len == 1, 'expected one make return, got ${returns}'
    ret_expr := returns[0]
    assert ret_expr is ast.InitExpr, '?Tree[int] return should wrap Node[int], got ${ret_expr}'
    ret_init := ret_expr as ast.InitExpr
    mono_assert_init_ident_name(ret_init, 'Tree_T_int')
    tag_value := mono_init_field(ret_init, '_tag') or {
        assert false, 'missing Tree_T_int _tag field in ${ret_init.fields}'
        return
    }
    mono_assert_basic_number_expr(tag_value, '1')
    payload_value := mono_init_field(ret_init, '_data._Node_T_int') or {
        assert false, 'missing Tree_T_int Node_T_int payload field in ${ret_init.fields}'
        return
    }
    mono_assert_sumtype_payload_memdup_expr(payload_value, 'Node_T_int')
}

fn test_result_concrete_sumtype_return_wraps_variant() {
    files := mono_transform_sources_for_test([
        MonoSource{
            rel:  'main.v'
            code: '
module main

struct Empty {}

struct Node[T] {
    value T
}

type Tree[T] = Empty | Node[T]

fn make() !Tree[int] {
    return Node[int]{value: 7}
}
'
        },
    ])
    make_decl := mono_fn_decl_by_name(files, 'make') or {
        assert false, 'missing transformed make function'
        return
    }
    returns := mono_return_exprs_for_decl(make_decl)
    assert returns.len == 1, 'expected one make return, got ${returns}'
    ret_expr := returns[0]
    assert ret_expr is ast.InitExpr, '!Tree[int] return should wrap Node[int], got ${ret_expr}'
    ret_init := ret_expr as ast.InitExpr
    mono_assert_init_ident_name(ret_init, 'Tree_T_int')
    tag_value := mono_init_field(ret_init, '_tag') or {
        assert false, 'missing Tree_T_int _tag field in ${ret_init.fields}'
        return
    }
    mono_assert_basic_number_expr(tag_value, '1')
    payload_value := mono_init_field(ret_init, '_data._Node_T_int') or {
        assert false, 'missing Tree_T_int Node_T_int payload field in ${ret_init.fields}'
        return
    }
    mono_assert_sumtype_payload_memdup_expr(payload_value, 'Node_T_int')
}

fn test_pointer_generic_sumtype_variant_uses_concrete_variant_name() {
    checked := mono_check_sources_for_test([
        MonoSource{
            rel:  'main.v'
            code: '
module main

struct Empty {}

struct Node[T] {
    value T
}

type Tree[T] = &Node[T] | Empty

fn make() Tree[int] {
    return &Node[int]{value: 7}
}
'
        },
    ])
    mut trans := checked.trans
    main_scope := trans.env.get_scope('main') or { panic('missing main scope') }
    tree_type := main_scope.lookup_type_parent('Tree', 0) or { panic('missing Tree type') }
    assert tree_type is types.SumType, 'expected Tree sum type, got ${tree_type}'
    tree := tree_type as types.SumType
    mut variants := []string{cap: tree.variants.len}
    bindings := {
        'T': types.Type(types.int_)
    }
    for variant in tree.variants {
        concrete_variant := trans.instantiate_generic_sumtype_variant(variant, bindings)
        variants << trans.type_to_c_name(concrete_variant)
    }
    assert variants == ['Node_T_intptr', 'Empty']
}

fn test_generic_sumtype_declared_param_order_is_preserved_for_crossed_variants() {
    checked := mono_check_sources_for_test([
        MonoSource{
            rel:  'main.v'
            code: '
module main

struct Left[T] {
    value T
}

struct Right[T] {
    value T
}

type Either[K, V] = Left[V] | Right[K]

fn make() Either[string, int] {
    return Left[int]{value: 1}
}
'
        },
    ])
    mut trans := checked.trans
    main_scope := trans.env.get_scope('main') or { panic('missing main scope') }
    either_type := main_scope.lookup_type_parent('Either', 0) or { panic('missing Either type') }
    params := generic_template_type_param_names_from_type(either_type)
    assert params == ['K', 'V'], 'Either generic param order should stay K,V, got ${params}'
    files := trans.transform_files(checked.files)
    make_decl := mono_fn_decl_by_name(files, 'make') or {
        assert false, 'missing transformed make function'
        return
    }
    returns := mono_return_exprs_for_decl(make_decl)
    assert returns.len == 1, 'expected one make return, got ${returns}'
    ret_expr := returns[0]
    assert ret_expr is ast.InitExpr, 'Either[string, int] return should wrap Left[int], got ${ret_expr}'
    ret_init := ret_expr as ast.InitExpr
    mono_assert_init_ident_name(ret_init, 'Either_T_string_int')
    tag_value := mono_init_field(ret_init, '_tag') or {
        assert false, 'missing Either_T_string_int _tag field in ${ret_init.fields}'
        return
    }
    mono_assert_basic_number_expr(tag_value, '0')
    payload_value := mono_init_field(ret_init, '_data._Left_T_int') or {
        assert false, 'missing Either_T_string_int Left_T_int payload field in ${ret_init.fields}'
        return
    }
    mono_assert_sumtype_payload_memdup_expr(payload_value, 'Left_T_int')
}

fn test_generic_template_type_param_names_handles_recursive_generic_struct_fields() {
    checked := mono_check_sources_for_test([
        MonoSource{
            rel:  'datatypes/linked_list.v'
            code: '
module datatypes

pub struct ListNode[T] {
mut:
    data T
    next &ListNode[T] = unsafe { nil }
}

pub struct LinkedList[T] {
mut:
    head &ListNode[T] = unsafe { nil }
}
'
        },
        MonoSource{
            rel:  'datatypes/queue.v'
            code: '
module datatypes

pub struct Queue[T] {
mut:
    elements LinkedList[T]
}
'
        },
        MonoSource{
            rel:  'main.v'
            code: '
module main

import datatypes

fn use() {
    _ := datatypes.Queue[[]string]{}
}
'
        },
    ])
    mut trans := checked.trans
    datatypes_scope := trans.env.get_scope('datatypes') or { panic('missing datatypes scope') }
    queue_type := datatypes_scope.lookup_type_parent('Queue', 0) or { panic('missing Queue type') }
    params := generic_template_type_param_names_from_type(queue_type)
    assert params == ['T'], 'recursive generic Queue params should be [T], got ${params}'
}

fn test_generic_template_type_param_names_collects_embedded_generic_params() {
    wrapper_type := types.Type(types.Struct{
        name:           'Wrapper'
        generic_params: ['T']
        fields:         [
            types.Field{
                name: 'value'
                typ:  types.Type(types.NamedType('T'))
            },
        ]
        embedded:       [
            types.Struct{
                name:           'Embedded'
                generic_params: ['U']
                fields:         [types.Field{
                    name: 'inner'
                    typ:  types.Type(types.NamedType('U'))
                }]
            },
        ]
    })
    params := generic_template_type_param_names_from_type(wrapper_type)
    assert params == ['T', 'U'], 'embedded generic params should be collected, got ${params}'
}

fn test_generic_template_type_param_names_keeps_same_name_different_generic_params_separate() {
    root_type := types.Type(types.Struct{
        name:   'Root'
        fields: [
            types.Field{
                name: 'left'
                typ:  types.Type(types.Struct{
                    name:           'Box'
                    generic_params: ['T']
                })
            },
            types.Field{
                name: 'right'
                typ:  types.Type(types.Struct{
                    name:           'Box'
                    generic_params: ['U']
                })
            },
        ]
    })
    params := generic_template_type_param_names_from_type(root_type)
    assert params == ['T', 'U'], 'same-name structs with different params should stay distinct, got ${params}'
}

fn test_generic_template_type_param_names_does_not_guard_empty_struct_names() {
    root_type := types.Type(types.Struct{
        fields: [
            types.Field{
                name: 'left'
                typ:  types.Type(types.Struct{
                    generic_params: ['T']
                })
            },
            types.Field{
                name: 'right'
                typ:  types.Type(types.Struct{
                    generic_params: ['U']
                })
            },
        ]
    })
    params := generic_template_type_param_names_from_type(root_type)
    assert params == ['T', 'U'], 'empty-name structs should not share one structural guard, got ${params}'
}

fn test_generic_sumtype_match_lowers_generic_branch_to_numeric_tag() {
    files := mono_transform_sources_for_test([
        MonoSource{
            rel:  'main.v'
            code: '
module main

struct Empty {}

struct Node[T] {
    value T
    left  Tree[T]
    right Tree[T]
}

type Tree[T] = Empty | Node[T]

fn tag(tree Tree[f64]) int {
    return match tree {
        Empty { 0 }
        Node[f64] { 1 }
    }
}
'
        },
    ])
    rhs_values := mono_tag_compare_rhs_for_fn(files, 'tag')
    mut saw_zero := false
    mut saw_one := false
    for rhs in rhs_values {
        assert rhs !is ast.IndexExpr, 'generic sumtype match left index rhs ${rhs}'
        assert rhs !is ast.GenericArgs, 'generic sumtype match left generic args rhs ${rhs}'
        assert rhs !is ast.GenericArgOrIndexExpr, 'generic sumtype match left generic arg/index rhs ${rhs}'
        if rhs is ast.BasicLiteral && rhs.kind == token.Token.number {
            if rhs.value == '0' {
                saw_zero = true
            }
            if rhs.value == '1' {
                saw_one = true
            }
        }
    }
    assert saw_zero, 'generic sumtype match missing Empty tag 0 in ${rhs_values}'
    assert saw_one, 'generic sumtype match missing Node[f64] tag 1 in ${rhs_values}'
}

fn test_sumtype_decl_variant_cache_records_concrete_generic_variants_only() {
    checked := mono_check_sources_for_test([
        MonoSource{
            rel:  'foo/box.v'
            code: '
module foo

pub struct Box[T] {
pub:
    value T
}
'
        },
        MonoSource{
            rel:  'main.v'
            code: '
module main

import foo as f

struct Empty {}

struct Node[T] {
    value T
}

struct Box[T] {
    value T
}

type Tree[T] = Empty | Node[T]
type Value = Box[int] | Box[string]
type ImportedValue = f.Box[int] | f.Box[string]
'
        },
    ])
    mut trans := checked.trans
    trans.pre_pass(checked.files)
    assert trans.get_sum_type_variants('Value') == ['Box_T_int', 'Box_T_string']
    assert trans.get_sum_type_variants('main__Value') == ['Box_T_int', 'Box_T_string']
    assert trans.get_sum_type_variants('ImportedValue') == ['foo__Box_T_int', 'foo__Box_T_string']
    assert trans.get_sum_type_variants('main__ImportedValue') == ['foo__Box_T_int',
        'foo__Box_T_string']
    assert 'Tree' !in trans.sum_type_decl_variant_names
    assert 'main__Tree' !in trans.sum_type_decl_variant_names

    flat := ast.flatten_files(checked.files)
    mut flat_trans := Transformer.new_with_pref(checked.trans.env, checked.trans.pref)
    flat_trans.pre_pass_from_flat(&flat)
    assert flat_trans.get_sum_type_variants('Value') == ['Box_T_int', 'Box_T_string']
    assert flat_trans.get_sum_type_variants('main__Value') == ['Box_T_int', 'Box_T_string']
    assert flat_trans.get_sum_type_variants('ImportedValue') == ['foo__Box_T_int',
        'foo__Box_T_string']
    assert flat_trans.get_sum_type_variants('main__ImportedValue') == [
        'foo__Box_T_int',
        'foo__Box_T_string',
    ]
    assert 'Tree' !in flat_trans.sum_type_decl_variant_names
    assert 'main__Tree' !in flat_trans.sum_type_decl_variant_names
}

fn test_generic_sumtype_match_uses_full_specialization_when_generic_base_repeats() {
    files := mono_transform_sources_for_test([
        MonoSource{
            rel:  'main.v'
            code: '
module main

struct Box[T] {
    value T
}

type Value = Box[int] | Box[string]

fn tag(value Value) int {
    return match value {
        Box[string] { 20 }
        else { 0 }
    }
}
'
        },
    ])
    assert_generic_sumtype_repeated_base_string_tag(files, 'legacy')
}

fn test_flat_direct_generic_sumtype_match_uses_full_specialization_when_generic_base_repeats() {
    files := mono_transform_sources_flat_direct_for_test([
        MonoSource{
            rel:  'main.v'
            code: '
module main

struct Box[T] {
    value T
}

type Value = Box[int] | Box[string]

fn tag(value Value) int {
    return match value {
        Box[string] { 20 }
        else { 0 }
    }
}
'
        },
    ])
    assert_generic_sumtype_repeated_base_string_tag(files, 'flat direct')
}

fn test_generic_sumtype_match_smartcast_scans_full_specialization_body() {
    files := mono_transform_sources_for_test([
        MonoSource{
            rel:  'main.v'
            code: generic_sumtype_repeated_base_smartcast_source()
        },
    ])
    assert_generic_sumtype_repeated_base_smartcast_echo(files, 'legacy')
}

fn test_flat_direct_generic_sumtype_match_smartcast_scans_full_specialization_body() {
    files := mono_transform_sources_flat_direct_for_test([
        MonoSource{
            rel:  'main.v'
            code: generic_sumtype_repeated_base_smartcast_source()
        },
    ])
    assert_generic_sumtype_repeated_base_smartcast_echo(files, 'flat direct')
}

fn generic_sumtype_repeated_base_smartcast_source() string {
    return '
module main

struct Box[T] {
    value T
}

type Value = Box[int] | Box[string]

fn echo[T](value T) T {
    return value
}

fn use(value Value) string {
    return match value {
        Box[string] { echo(value.value) }
        else { "" }
    }
}
'
}

fn assert_generic_sumtype_repeated_base_string_tag(files []ast.File, label string) {
    rhs_values := mono_tag_compare_rhs_for_fn(files, 'tag')
    mut saw_string_tag := false
    for rhs in rhs_values {
        assert rhs !is ast.IndexExpr, '${label}: generic sumtype repeated base left index rhs ${rhs}'
        assert rhs !is ast.GenericArgs, '${label}: generic sumtype repeated base left generic args rhs ${rhs}'
        assert rhs !is ast.GenericArgOrIndexExpr, '${label}: generic sumtype repeated base left generic arg/index rhs ${rhs}'
        if rhs is ast.BasicLiteral && rhs.kind == token.Token.number {
            assert rhs.value != '0', '${label}: Box[string] branch matched first Box[int] tag in ${rhs_values}'
            if rhs.value == '1' {
                saw_string_tag = true
            }
        }
    }
    assert saw_string_tag, '${label}: Box[string] branch should match the second generic specialization tag, got ${rhs_values}'
}

fn assert_generic_sumtype_repeated_base_smartcast_echo(files []ast.File, label string) {
    fn_names := mono_fn_names(files)
    assert 'echo_T_string' in fn_names, '${label}: smartcasted Box[string] branch did not collect echo[string], got ${fn_names}'
    assert 'echo_T_int' !in fn_names, '${label}: Box[string] branch collected wrong echo[int] specialization, got ${fn_names}'
    call_names := mono_call_names_for_fn(files, 'use')
    assert 'echo_T_string' in call_names, '${label}: use() should call echo_T_string from Box[string] branch, got ${call_names}'
    assert 'echo' !in call_names, '${label}: open echo call leaked in ${call_names}'
}

fn test_generic_sumtype_receiver_no_arg_method_call_is_monomorphized() {
    files := mono_transform_sources_for_test([
        MonoSource{
            rel:  'main.v'
            code: '
module main

struct Empty {}

struct Node[T] {
    value T
}

type Tree[T] = Empty | Node[T]

fn (tree Tree[T]) size[T]() int {
    return 0
}

fn use() int {
    tree := Tree[f64](Empty{})
    return tree.size()
}
'
        },
    ])
    fn_names := mono_fn_names(files)
    call_names := mono_call_names_for_fn(files, 'use')
    mono_assert_method_clone_by_receiver(files, 'Tree_T_f64', 'size_T_f64')
    assert call_names == ['Tree_T_f64__size_T_f64'], 'expected concrete Tree[f64].size call, got ${call_names}'
    assert 'Tree__size' !in fn_names
    assert 'Tree__size' !in call_names
    assert 'Tree_T_f64' !in call_names
}

fn test_generic_sumtype_receiver_recursive_size_calls_are_monomorphized() {
    files := mono_transform_sources_for_test([
        MonoSource{
            rel:  'main.v'
            code: '
module main

struct Empty {}

struct Node[T] {
    value T
    left  Tree[T]
    right Tree[T]
}

type Tree[T] = Empty | Node[T]

fn (tree Tree[T]) size[T]() int {
    return match tree {
        Empty { 0 }
        Node[T] { 1 + tree.left.size() + tree.right.size() }
    }
}

fn use() string {
    tree := Tree[f64](Empty{})
    return "size \${tree.size()}"
}
'
        },
    ])
    fn_names := mono_fn_names(files)
    use_call_names := mono_call_names_for_fn(files, 'use')
    size_decl := mono_assert_method_clone_by_receiver(files, 'Tree_T_f64', 'size_T_f64')
    size_call_names := mono_call_names_for_decl(size_decl)
    assert 'Tree_T_f64__size_T_f64' in use_call_names, 'interpolation should call concrete Tree[f64].size, got ${use_call_names}'
    assert size_call_names == [
        'Tree_T_f64__size_T_f64',
        'Tree_T_f64__size_T_f64',
    ], 'recursive Tree[f64].size body should call concrete size twice, got ${size_call_names}'
    assert 'Tree__size' !in fn_names
    assert 'Tree__size' !in use_call_names
    assert 'Tree__size' !in size_call_names
    assert 'Tree_T_T__size_T' !in fn_names
    assert 'Tree_T_T__size_T' !in use_call_names
    assert 'Tree_T_T__size_T' !in size_call_names
    assert 'Tree_T_f64' !in use_call_names
}

fn test_generic_sumtype_receiver_match_lowers_generic_branch_to_numeric_tag() {
    files := mono_transform_sources_for_test([
        MonoSource{
            rel:  'main.v'
            code: '
module main

struct Empty {}

struct Node[T] {
    value T
    left  Tree[T]
    right Tree[T]
}

type Tree[T] = Empty | Node[T]

fn (tree Tree[T]) size[T]() int {
    return match tree {
        Empty { 0 }
        Node[T] { 1 }
    }
}

fn use() int {
    empty := Tree[f64](Empty{})
    tree := Tree[f64](Node[f64]{1.0, empty, empty})
    return tree.size()
}
'
        },
    ])
    fn_names := mono_fn_names(files)
    call_names := mono_call_names_for_fn(files, 'use')
    size_decl := mono_assert_method_clone_by_receiver(files, 'Tree_T_f64', 'size_T_f64')
    assert call_names == ['Tree_T_f64__size_T_f64'], 'expected concrete Tree[f64].size call, got ${call_names}'
    assert 'Tree_T_T__size_T' !in fn_names
    assert 'Tree_T_T__size_T' !in call_names
    rhs_values := mono_tag_compare_rhs_for_decl(size_decl)
    mut saw_zero := false
    mut saw_one := false
    for rhs in rhs_values {
        assert rhs !is ast.IndexExpr, 'generic receiver match left index rhs ${rhs}'
        assert rhs !is ast.GenericArgs, 'generic receiver match left generic args rhs ${rhs}'
        assert rhs !is ast.GenericArgOrIndexExpr, 'generic receiver match left generic arg/index rhs ${rhs}'
        if rhs is ast.BasicLiteral && rhs.kind == token.Token.number {
            if rhs.value == '0' {
                saw_zero = true
            }
            if rhs.value == '1' {
                saw_one = true
            }
        }
    }
    assert saw_zero, 'generic receiver match missing Empty tag 0 in ${rhs_values}'
    assert saw_one, 'generic receiver match missing Node[T] tag 1 in ${rhs_values}'
}

fn test_generic_sumtype_receiver_nested_min_call_is_monomorphized() {
    files := mono_transform_sources_for_test([
        MonoSource{
            rel:  'main.v'
            code: mono_nested_min_source()
        },
    ])
    fn_names := mono_fn_names(files)
    use_call_names := mono_call_names_for_fn(files, 'use')
    take_min_decl := mono_assert_method_clone_by_receiver(files, 'Tree_T_f64', 'take_min_T_f64')
    take_min_call_names := mono_call_names_for_decl(take_min_decl)
    assert use_call_names == ['Tree_T_f64__take_min_T_f64'], 'expected use to call only concrete take_min, got ${use_call_names}'
    assert 'Tree_T_f64__min_T_f64' in take_min_call_names, 'take_min min-call classification: calls=${take_min_call_names}; has_concrete=${'Tree_T_f64__min_T_f64' in take_min_call_names}; has_open_tree=${'Tree__min' in take_min_call_names}; has_open_generic=${'Tree_T_T__min_T' in take_min_call_names}; has_raw_min=${'min' in take_min_call_names}; has_any_min=${take_min_call_names.any(it.contains('min'))}'
    if _ := mono_method_decl_by_receiver(files, 'Tree_T_f64', 'min_T_f64') {
    } else {
        assert false, 'missing concrete method clone Tree_T_f64.min_T_f64; take_min_call_names=${take_min_call_names}; fn_names=${fn_names}; has_concrete_call=${'Tree_T_f64__min_T_f64' in take_min_call_names}; has_open_tree=${'Tree__min' in take_min_call_names}; has_open_generic=${'Tree_T_T__min_T' in take_min_call_names}; has_raw_min=${'min' in take_min_call_names}; has_any_min=${take_min_call_names.any(it.contains('min'))}'
    }
    assert 'Tree_T_f64__min_T_f64' in take_min_call_names, 'concrete take_min should call concrete min, got ${take_min_call_names}'
    for names in [fn_names, use_call_names, take_min_call_names] {
        assert 'Tree__min' !in names
        assert 'Tree_T_T__min_T' !in names
        assert 'Node_T' !in names
        assert 'Node_T_T' !in names
        assert 'unknown__min' !in names
        for name in names {
            assert !name.contains('unknown__'), 'unresolved generic receiver call leaked in ${names}'
            assert !name.contains('Tree_T_T__min_T'), 'open generic min call leaked in ${names}'
            assert !name.contains('Node_T_T'), 'open generic Node leaked in ${names}'
        }
    }
}

fn test_generic_sumtype_receiver_nested_min_collects_smartcast_callee() {
    checked := mono_check_sources_for_test([
        MonoSource{
            rel:  'main.v'
            code: mono_nested_min_source()
        },
    ])
    mut trans := checked.trans
    files := checked.files
    trans.env.generic_types = map[string][]map[string]types.Type{}
    trans.pre_pass(files)
    trans.collect_declared_method_fns(files)
    trans.collect_struct_field_generic_decl_types(files)
    trans.collect_generic_call_specs(files)
    sig := 'T:f64'
    before_has_take_min := mono_has_spec(trans, 'Tree__take_min', sig)
    before_has_min := mono_has_spec(trans, 'Tree__min', sig)
    before_specs := mono_specs_summary(trans)
    prepared := trans.monomorphize_pass(files)
    clone_names := mono_last_clone_names(trans)
    mut take_min_call_names := []string{}
    mut take_min_call_shapes := []string{}
    if take_min_decl := mono_last_clone_decl(trans, 'Tree_T_f64__take_min_T_f64') {
        take_min_call_names = mono_raw_call_names_for_decl(take_min_decl)
        take_min_call_shapes = mono_call_lhs_shapes_for_decl(take_min_decl)
    }
    binding_summary := mono_binding_lookup_summary(trans, [
        'Tree_T_f64__take_min_T_f64',
        'take_min_T_f64',
        'Tree_T_f64__take_min',
    ])
    trans.collect_generic_call_specs_in_new_clones(prepared)
    after_has_min := mono_has_spec(trans, 'Tree__min', sig)
    after_specs := mono_specs_summary(trans)
    assert before_has_take_min, 'expected initial take_min spec; before_specs=${before_specs}'
    assert !before_has_min, 'min spec should be discovered from the first take_min clone, before_specs=${before_specs}'
    assert 'Tree_T_f64__take_min_T_f64' in clone_names, 'missing first take_min clone; clones=${clone_names}'
    assert take_min_call_names == ['min'], 'first take_min clone should still contain raw selector call before collect2; calls=${take_min_call_names}; shapes=${take_min_call_shapes}'
    assert take_min_call_shapes == ['Selector(Selector(Ident(tree).right).min)'], 'unexpected take_min clone call shape before collect2: ${take_min_call_shapes}'
    assert binding_summary.contains('Tree_T_f64__take_min_T_f64=T:f64'), 'missing take_min clone bindings: ${binding_summary}'
    assert after_has_min, 'collect2 should discover Tree__min ${sig}; after_specs=${after_specs}'
    assert after_specs.contains('Tree__min=[${sig}]'), 'missing concrete min spec after collect2; after_specs=${after_specs}'
    assert !after_specs.contains('Tree_T_T__min_T'), 'open generic min spec leaked after collect2: ${after_specs}'
    assert !after_specs.contains('unknown__min'), 'unknown min spec leaked after collect2: ${after_specs}'
}

fn test_generic_sumtype_receiver_insert_return_wraps_concrete_variant() {
    checked := mono_check_sources_for_test([
        MonoSource{
            rel:  'main.v'
            code: mono_insert_size_source()
        },
    ])
    mut trans := checked.trans
    files := trans.transform_files(checked.files)
    fn_names := mono_fn_names(files)
    use_call_names := mono_call_names_for_fn(files, 'use')
    insert_decl := mono_assert_method_clone_by_receiver(files, 'Tree_T_f64', 'insert_T_f64')
    binding_summary := mono_binding_lookup_summary(trans, [
        'Tree_T_f64__insert_T_f64',
        'insert_T_f64',
        'Tree_T_f64__insert',
    ])
    mono_assert_method_clone_by_receiver(files, 'Tree_T_f64', 'size_T_f64')
    insert_returns := mono_return_exprs_for_decl(insert_decl)
    mut assoc_type_summary := []string{}
    for ret_expr in insert_returns {
        if ret_expr is ast.Ident && ret_expr.name.starts_with('_assoc_t') {
            assoc_type_summary << if typ := trans.lookup_var_type(ret_expr.name) {
                '${ret_expr.name}:${trans.type_to_c_name(typ)}'
            } else {
                '${ret_expr.name}:<none>'
            }
        }
    }
    mut node_wrap_count := 0
    mut saw_node_wrap := false
    for ret_expr in insert_returns {
        assert ret_expr !is ast.GenericArgs, 'insert returned open GenericArgs ${ret_expr}'
        assert ret_expr !is ast.GenericArgOrIndexExpr, 'insert returned open GenericArgOrIndexExpr ${ret_expr}'
        assert ret_expr !is ast.Ident || (ret_expr as ast.Ident).name != 'Node_T_f64', 'insert returned raw Node_T_f64 variant instead of Tree_T_f64 wrapper'

        if ret_expr is ast.InitExpr {
            if ret_expr.typ is ast.Ident {
                assert ret_expr.typ.name != 'Node_T_f64', 'insert returned raw Node_T_f64 init instead of Tree_T_f64 wrapper: ${insert_returns}'
            }
        }

        if ret_expr is ast.InitExpr {
            if ret_expr.typ is ast.Ident && ret_expr.typ.name == 'Tree_T_f64' {
                tag_value := mono_init_field(ret_expr, '_tag') or { continue }
                if tag_value is ast.BasicLiteral && tag_value.value == '1' {
                    node_wrap_count++
                    payload_value := mono_init_field(ret_expr, '_data._Node_T_f64') or { continue }
                    if payload_value is ast.CastExpr && payload_value.expr is ast.CallExpr {
                        memdup_call := payload_value.expr as ast.CallExpr
                        if memdup_call.args.len == 2 && memdup_call.args[0] is ast.PrefixExpr {
                            payload_ref := memdup_call.args[0] as ast.PrefixExpr
                            if payload_ref.expr is ast.InitExpr {
                                mono_assert_sumtype_payload_memdup_expr(payload_value, 'Node_T_f64')
                                saw_node_wrap = true
                            }
                        }
                    }
                }
            }
        }
    }
    assert saw_node_wrap, 'Tree_T_f64.insert_T_f64 should wrap Node_T_f64 return with tag 1; return_type=${insert_decl.typ.return_type}; bindings=${binding_summary}; returns=${insert_returns}; fn_names=${fn_names}; use_calls=${use_call_names}'
    assert node_wrap_count >= 3, 'Tree_T_f64.insert_T_f64 should wrap Empty plus both recursive Node branches; got ${node_wrap_count}; assoc_types=${assoc_type_summary}; returns=${insert_returns}'
    for names in [fn_names, use_call_names, mono_call_names_for_decl(insert_decl)] {
        assert 'Tree_T_T__insert_T' !in names
        assert 'Node_T' !in names
        assert 'Node_T_T' !in names
        for name in names {
            assert !name.contains('Tree_T_T'), 'open Tree generic leaked in ${names}'
            assert !name.contains('Node_T_T'), 'open Node generic leaked in ${names}'
        }
    }
}

fn test_shadowed_local_receiver_names_keep_distinct_generic_bindings() {
    files := mono_transform_sources_for_test([
        MonoSource{
            rel:  'main.v'
            code: '
module main

struct Queue[T] {
mut:
    elements []T
}

fn (queue Queue[T]) is_empty() bool {
    return queue.elements.len == 0
}

fn use_strings() bool {
    mut queue := Queue[[]string]{}
    return queue.is_empty()
}

fn use_ints() bool {
    mut queue := Queue[int]{}
    return queue.is_empty()
}
'
        },
    ])
    fn_names := mono_fn_names(files)
    string_call_names := mono_call_names_for_fn(files, 'use_strings')
    int_call_names := mono_call_names_for_fn(files, 'use_ints')
    mono_assert_method_clone_by_receiver(files, 'Queue_T_Array_string', 'is_empty')
    mono_assert_method_clone_by_receiver(files, 'Queue_T_int', 'is_empty')
    assert string_call_names == ['Queue_T_Array_string__is_empty'], 'expected shadowed string queue call, got ${string_call_names}'
    assert int_call_names == ['Queue_T_int__is_empty'], 'expected shadowed int queue call, got ${int_call_names}'
    mono_assert_no_open_queue_is_empty_names(fn_names, string_call_names)
    mono_assert_no_open_queue_is_empty_names(fn_names, int_call_names)
}

fn test_explicit_generic_str_interpolation_uses_specialized_method_not_auto_str() {
    files := mono_transform_sources_for_test([
        MonoSource{
            rel:  'main.v'
            code: '
module main

struct Box[T] {
    value T
}

fn (box Box[T]) str() string {
    return "explicit-box"
}

fn use(value int) string {
    box := Box[int]{value: value}
    return "\${box}"
}
'
        },
    ])
    fn_names := mono_fn_names(files)
    box_str := mono_assert_method_clone_by_receiver(files, 'Box_T_int', 'str')
    assert 'Box_T_int__str' !in fn_names, 'auto-str/full-symbol FnDecl should not replace explicit generic method: ${fn_names}'
    assert 'Box__str' !in fn_names
    literals := mono_string_literals_for_decl(box_str)
    assert '"explicit-box"' in literals, 'explicit generic str body was not cloned, got literals ${literals}'
    call_names := mono_call_names_for_fn(files, 'use')
    assert call_names == ['Box_T_int__str'], 'interpolation should call specialized explicit str, got ${call_names}'
    mono_assert_no_open_str_calls(call_names, [
        'Box__str',
        'main__Box__str',
    ])
}

fn test_flat_direct_explicit_generic_str_interpolation_uses_specialized_method_not_auto_str() {
    files := mono_transform_sources_flat_direct_for_test([
        MonoSource{
            rel:  'main.v'
            code: '
module main

struct Box[T] {
    value T
}

fn (box Box[T]) str() string {
    return "explicit-box"
}

fn use(value int) string {
    box := Box[int]{value: value}
    return "\${box}"
}
'
        },
    ])
    fn_names := mono_fn_names(files)
    box_str := mono_assert_method_clone_by_receiver(files, 'Box_T_int', 'str')
    assert 'Box_T_int__str' !in fn_names, 'auto-str/full-symbol FnDecl should not replace explicit generic method: ${fn_names}'
    assert 'Box__str' !in fn_names
    literals := mono_string_literals_for_decl(box_str)
    assert '"explicit-box"' in literals, 'flat direct explicit generic str body was not cloned, got literals ${literals}'
    call_names := mono_call_names_for_fn(files, 'use')
    assert call_names == ['Box_T_int__str'], 'flat direct interpolation should call specialized explicit str, got ${call_names}'
    mono_assert_no_open_str_calls(call_names, [
        'Box__str',
        'main__Box__str',
    ])
}

fn test_nested_generic_explicit_str_rewrites_internal_str_calls() {
    files := mono_transform_sources_for_test([
        MonoSource{
            rel:  'datatypes/node.v'
            code: '
module datatypes

pub struct ListNode[T] {
    value T
}

pub fn (node ListNode[T]) str() string {
    return "node"
}
'
        },
        MonoSource{
            rel:  'datatypes/linked_list.v'
            code: '
module datatypes

pub struct LinkedList[T] {
    head ListNode[T]
}

pub fn (list LinkedList[T]) str() string {
    return "\${list.head}"
}
'
        },
        MonoSource{
            rel:  'datatypes/queue.v'
            code: '
module datatypes

pub struct Queue[T] {
    list LinkedList[T]
}

pub fn (queue Queue[T]) str() string {
    return "\${queue.list}"
}
'
        },
        MonoSource{
            rel:  'main.v'
            code: '
module main

import datatypes

fn use() string {
    queue := datatypes.Queue[[]string]{}
    return "\${queue}"
}
'
        },
    ])
    queue_str := mono_assert_method_clone_by_receiver(files, 'Queue_T_Array_string', 'str')
    linked_str := mono_assert_method_clone_by_receiver(files, 'LinkedList_T_Array_string', 'str')
    mono_assert_method_clone_by_receiver(files, 'ListNode_T_Array_string', 'str')
    call_names := mono_call_names_for_fn(files, 'use')
    assert call_names == ['datatypes__Queue_T_Array_string__str'], 'interpolation should call specialized Queue str, got ${call_names}'
    mono_assert_no_open_str_calls(call_names, [
        'datatypes__Queue__str',
        'Queue__str',
    ])
    queue_body_calls := mono_call_names_for_decl(queue_str)
    linked_body_calls := mono_call_names_for_decl(linked_str)
    assert 'datatypes__LinkedList_T_Array_string__str' in queue_body_calls, 'Queue str body should call specialized LinkedList str, got ${queue_body_calls}'
    mono_assert_no_open_str_calls(queue_body_calls, [
        'datatypes__LinkedList__str',
        'LinkedList__str',
    ])
    assert 'datatypes__ListNode_T_Array_string__str' in linked_body_calls, 'LinkedList str body should call specialized ListNode str, got ${linked_body_calls}'
    mono_assert_no_open_str_calls(linked_body_calls, [
        'datatypes__ListNode__str',
        'ListNode__str',
    ])
}

fn test_flat_direct_queue_nested_array_str_interpolation_forces_str_cascade() {
    files := mono_transform_sources_flat_direct_for_test([
        MonoSource{
            rel:  'datatypes/linked_list.v'
            code: '
module datatypes

pub struct LinkedList[T] {
mut:
    values []T
}

pub fn (mut list LinkedList[T]) push(value T) {
    list.values << value
}

pub fn (list LinkedList[T]) array() []T {
    return list.values
}

pub fn (list LinkedList[T]) str() string {
    return list.array().str()
}
'
        },
        MonoSource{
            rel:  'datatypes/queue.v'
            code: '
module datatypes

pub struct Queue[T] {
mut:
    elements LinkedList[T]
}

pub fn (mut queue Queue[T]) push(value T) {
    queue.elements.push(value)
}

pub fn (queue Queue[T]) str() string {
    return queue.elements.str()
}
'
        },
        MonoSource{
            rel:  'main.v'
            code: '
module main

import datatypes

fn use(value []string) string {
    mut queue := datatypes.Queue[[]string]{}
    queue.push(value)
    return "\${queue}"
}
'
        },
    ])
    fn_names := mono_fn_names(files)
    call_names := mono_call_names_for_fn(files, 'use')
    queue_push := mono_assert_method_clone_by_receiver(files, 'Queue_T_Array_string', 'push')
    queue_str := mono_assert_method_clone_by_receiver(files, 'Queue_T_Array_string', 'str')
    linked_push := mono_assert_method_clone_by_receiver(files, 'LinkedList_T_Array_string', 'push')
    linked_str := mono_assert_method_clone_by_receiver(files, 'LinkedList_T_Array_string', 'str')
    mono_assert_method_clone_by_receiver(files, 'LinkedList_T_Array_string', 'array')
    assert 'datatypes__Queue_T_Array_string__str' !in fn_names, 'auto-str/full-symbol FnDecl should not replace explicit Queue.str: ${fn_names}'
    assert call_names == [
        'datatypes__Queue_T_Array_string__push',
        'datatypes__Queue_T_Array_string__str',
    ], 'flat direct Queue interpolation should call specialized explicit str without a prior queue.str(), got ${call_names}'
    queue_push_calls := mono_call_names_for_decl(queue_push)
    queue_str_calls := mono_call_names_for_decl(queue_str)
    linked_push_calls := mono_call_names_for_decl(linked_push)
    linked_str_calls := mono_call_names_for_decl(linked_str)
    assert 'datatypes__LinkedList_T_Array_string__push' in queue_push_calls, 'Queue.push body should specialize LinkedList.push, got ${queue_push_calls}'
    assert 'datatypes__LinkedList_T_Array_string__str' in queue_str_calls, 'Queue.str body should specialize LinkedList.str, got ${queue_str_calls}'
    assert 'datatypes__LinkedList_T_Array_string__array' in linked_str_calls, 'LinkedList.str body should specialize LinkedList.array, got ${linked_str_calls}'
    assert 'Array_Array_string_str' in linked_str_calls, 'LinkedList.str body should call nested array str helper, got ${linked_str_calls}'
    mono_assert_no_unresolved_generic_receiver_names(fn_names, 'flat direct Queue str fn decls')
    mono_assert_no_unresolved_generic_receiver_names(call_names,
        'flat direct Queue interpolation body')
    mono_assert_no_unresolved_generic_receiver_names(queue_push_calls,
        'flat direct Queue.push body')
    mono_assert_no_unresolved_generic_receiver_names(queue_str_calls, 'flat direct Queue.str body')
    mono_assert_no_unresolved_generic_receiver_names(linked_push_calls,
        'flat direct LinkedList.push body')
    mono_assert_no_unresolved_generic_receiver_names(linked_str_calls,
        'flat direct LinkedList.str body')
    mono_assert_no_open_str_calls(call_names, [
        'datatypes__Queue__str',
        'Queue__str',
    ])
    mono_assert_no_open_str_calls(queue_str_calls, [
        'datatypes__LinkedList__str',
        'LinkedList__str',
    ])
}

fn test_flat_direct_imported_generic_receiver_clone_body_keeps_bindings() {
    files := mono_transform_sources_flat_direct_for_test([
        MonoSource{
            rel:  'datatypes/linked_list.v'
            code: '
module datatypes

pub struct LinkedList[T] {
mut:
    values []T
}

pub fn (mut list LinkedList[T]) push(value T) {
    list.values << value
}

pub fn (list LinkedList[T]) is_empty() bool {
    return list.values.len == 0
}

pub fn (mut list LinkedList[T]) shift() !T {
    return list.values[0]
}
'
        },
        MonoSource{
            rel:  'datatypes/queue.v'
            code: '
module datatypes

pub struct Queue[T] {
mut:
    elements LinkedList[T]
}

pub fn (mut queue Queue[T]) push(value T) {
    queue.elements.push(value)
}

pub fn (queue Queue[T]) is_empty() bool {
    return queue.elements.is_empty()
}

pub fn (mut queue Queue[T]) pop() !T {
    return queue.elements.shift()
}
'
        },
        MonoSource{
            rel:  'main.v'
            code: '
module main

import datatypes

fn use(value []string) bool {
    mut queue := datatypes.Queue[[]string]{}
    queue.push(value)
    if queue.is_empty() {
        return false
    }
    popped := queue.pop() or { return false }
    return popped.len == 1
}
'
        },
    ])
    fn_names := mono_fn_names(files)
    call_names := mono_call_names_for_fn(files, 'use')
    queue_push := mono_assert_method_clone_by_receiver(files, 'Queue_T_Array_string', 'push')
    queue_is_empty := mono_assert_method_clone_by_receiver(files, 'Queue_T_Array_string',
        'is_empty')
    queue_pop := mono_assert_method_clone_by_receiver(files, 'Queue_T_Array_string', 'pop')
    mono_assert_method_clone_by_receiver(files, 'LinkedList_T_Array_string', 'push')
    mono_assert_method_clone_by_receiver(files, 'LinkedList_T_Array_string', 'is_empty')
    mono_assert_method_clone_by_receiver(files, 'LinkedList_T_Array_string', 'shift')
    assert call_names == [
        'datatypes__Queue_T_Array_string__push',
        'datatypes__Queue_T_Array_string__is_empty',
        'datatypes__Queue_T_Array_string__pop',
    ], 'flat direct should specialize imported Queue[[]string] calls, got ${call_names}'
    push_body_calls := mono_call_names_for_decl(queue_push)
    is_empty_body_calls := mono_call_names_for_decl(queue_is_empty)
    pop_body_calls := mono_call_names_for_decl(queue_pop)
    assert 'datatypes__LinkedList_T_Array_string__push' in push_body_calls, 'Queue.push body should specialize LinkedList.push, got ${push_body_calls}'
    assert 'datatypes__LinkedList_T_Array_string__is_empty' in is_empty_body_calls, 'Queue.is_empty body should specialize LinkedList.is_empty, got ${is_empty_body_calls}'
    assert 'datatypes__LinkedList_T_Array_string__shift' in pop_body_calls, 'Queue.pop body should specialize LinkedList.shift, got ${pop_body_calls}'
    mono_assert_no_unresolved_generic_receiver_names(fn_names, 'flat direct fn decls')
    mono_assert_no_unresolved_generic_receiver_names(call_names, 'flat direct use body')
    mono_assert_no_unresolved_generic_receiver_names(push_body_calls, 'flat direct Queue.push body')
    mono_assert_no_unresolved_generic_receiver_names(is_empty_body_calls,
        'flat direct Queue.is_empty body')
    mono_assert_no_unresolved_generic_receiver_names(pop_body_calls, 'flat direct Queue.pop body')
}

fn test_transform_dijkstra_shape_rewrites_inferred_generic_nested_array_call() {
    files := mono_transform_dijkstra_shape_for_test()
    call_names := mono_call_names_for_fn(files, 'dijkstra')
    assert 'all_adjacents_T_int' in call_names
    assert 'all_adjacents' !in call_names
    assert mono_has_fn(files, 'all_adjacents_T_int')
}

fn test_inferred_generic_call_name_for_nested_array_param() {
    mut t := mono_test_transformer()
    t.cur_module = 'main'
    t.generic_fn_decl_index['all_adjacents'] = ast.FnDecl{
        name: 'all_adjacents'
        typ:  ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'T'
                }),
            ]
            params:         [
                ast.Parameter{
                    name: 'g'
                    typ:  ast.Expr(ast.Type(ast.ArrayType{
                        elem_type: ast.Expr(ast.Type(ast.ArrayType{
                            elem_type: ast.Expr(ast.Ident{
                                name: 'T'
                            })
                        }))
                    }))
                },
                ast.Parameter{
                    name: 'v'
                    typ:  ast.Expr(ast.Ident{
                        name: 'int'
                    })
                },
            ]
        }
    }
    t.local_decl_types['g'] = types.Type(types.Array{
        elem_type: types.Type(types.Array{
            elem_type: types.Type(types.int_)
        })
    })
    info := CallFnInfo{
        param_types:                    [
            types.Type(types.Array{
                elem_type: types.Type(types.Array{
                    elem_type: types.Type(types.NamedType('T'))
                })
            }),
            types.Type(types.int_),
        ]
        generic_param_names_by_param:   ['T', '']
        generic_param_indexes_by_param: [0, -1]
        generic_params:                 ['T']
    }
    call_name := t.inferred_generic_call_name('all_adjacents', info, [
        ast.Expr(ast.Ident{
            name: 'g'
        }),
        ast.Expr(ast.Ident{
            name: 'v'
        }),
    ]) or { panic('missing inferred generic call name') }
    assert call_name == 'all_adjacents_T_int'
}

fn test_generic_call_info_preserves_nested_array_generic_param() {
    mut t := mono_test_transformer()
    t.cur_module = 'main'
    t.generic_fn_decl_index['all_adjacents'] = ast.FnDecl{
        name: 'all_adjacents'
        typ:  ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'T'
                }),
            ]
            params:         [
                ast.Parameter{
                    name: 'g'
                    typ:  ast.Expr(ast.Type(ast.ArrayType{
                        elem_type: ast.Expr(ast.Type(ast.ArrayType{
                            elem_type: ast.Expr(ast.Ident{
                                name: 'T'
                            })
                        }))
                    }))
                },
            ]
        }
    }
    info := t.generic_call_info_for_decl('all_adjacents') or { panic('missing generic call info') }
    assert info.param_types.len == 1
    outer := info.param_types[0] as types.Array
    inner := outer.elem_type as types.Array
    assert inner.elem_type.name() == 'T'
}

fn test_transform_rewrites_inferred_generic_call_for_nested_array_param() {
    mut t := mono_test_transformer()
    t.cur_module = 'main'
    t.generic_fn_decl_index['all_adjacents'] = ast.FnDecl{
        name: 'all_adjacents'
        typ:  ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'T'
                }),
            ]
            params:         [
                ast.Parameter{
                    name: 'g'
                    typ:  ast.Expr(ast.Type(ast.ArrayType{
                        elem_type: ast.Expr(ast.Type(ast.ArrayType{
                            elem_type: ast.Expr(ast.Ident{
                                name: 'T'
                            })
                        }))
                    }))
                },
                ast.Parameter{
                    name: 'v'
                    typ:  ast.Expr(ast.Ident{
                        name: 'int'
                    })
                },
            ]
        }
    }
    t.local_decl_types['g'] = types.Type(types.Array{
        elem_type: types.Type(types.Array{
            elem_type: types.Type(types.int_)
        })
    })
    t.local_decl_types['v'] = types.Type(types.int_)
    out := t.transform_call_expr(ast.CallExpr{
        lhs:  ast.Ident{
            name: 'all_adjacents'
        }
        args: [
            ast.Expr(ast.Ident{
                name: 'g'
            }),
            ast.Expr(ast.Ident{
                name: 'v'
            }),
        ]
    })
    assert out is ast.CallExpr
    call := out as ast.CallExpr
    assert call.lhs is ast.Ident
    assert (call.lhs as ast.Ident).name == 'all_adjacents_T_int'
}

fn test_clone_fn_decl_substitutes_fn_literal_signature() {
    mut t := mono_test_transformer()
    decl := ast.FnDecl{
        name:  'make'
        typ:   ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'T'
                }),
            ]
        }
        stmts: [
            ast.Stmt(ast.ReturnStmt{
                exprs: [
                    ast.Expr(ast.FnLiteral{
                        typ:   ast.FnType{
                            params:      [
                                ast.Parameter{
                                    name: 'x'
                                    typ:  ast.Expr(ast.Ident{
                                        name: 'T'
                                    })
                                },
                            ]
                            return_type: ast.Expr(ast.Ident{
                                name: 'T'
                            })
                        }
                        stmts: [
                            ast.Stmt(ast.ReturnStmt{
                                exprs: [
                                    ast.Expr(ast.Ident{
                                        name: 'x'
                                    }),
                                ]
                            }),
                        ]
                    }),
                ]
            }),
        ]
    }
    cloned := t.clone_fn_decl_with_substitutions(decl, {
        'T': types.Type(types.int_)
    }, 'make_T_int', 'main', 'main')
    ret := cloned.stmts[0] as ast.ReturnStmt
    lit := ret.exprs[0] as ast.FnLiteral
    param_typ := lit.typ.params[0].typ as ast.Ident
    return_typ := lit.typ.return_type as ast.Ident

    assert param_typ.name == 'int'
    assert return_typ.name == 'int'
}

fn test_monomorphize_pass_keeps_imported_clone_in_declaring_file() {
    mut t := mono_test_transformer()
    t.env = types.Environment.new()
    bindings := {
        'T': types.Type(types.string_)
    }
    t.env.generic_types['m__wrap'] = [bindings]
    t.generic_spec_owner_file[generic_spec_owner_key('m__wrap', bindings)] = 1
    helper_decl := ast.FnDecl{
        name: 'helper'
        typ:  ast.FnType{
            return_type: ast.Expr(ast.Ident{
                name: 'int'
            })
        }
    }
    decl := ast.FnDecl{
        name:  'wrap'
        typ:   ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'T'
                }),
            ]
            return_type:    ast.Expr(ast.Ident{
                name: 'int'
            })
        }
        stmts: [
            ast.Stmt(ast.ReturnStmt{
                exprs: [
                    ast.Expr(ast.CallExpr{
                        lhs: ast.Expr(ast.Ident{
                            name: 'helper'
                        })
                    }),
                ]
            }),
        ]
    }
    files := [
        ast.File{
            mod:   'm'
            stmts: [ast.Stmt(helper_decl), ast.Stmt(decl)]
        },
        ast.File{
            mod: 'main'
        },
    ]
    out := t.monomorphize_pass(files)
    assert out[0].stmts.len == 3
    assert out[1].stmts.len == 0
    assert out[0].stmts[2] is ast.FnDecl
    cloned := out[0].stmts[2] as ast.FnDecl
    assert cloned.name == 'm__wrap_T_string'
    ret := cloned.stmts[0] as ast.ReturnStmt
    call := ret.exprs[0] as ast.CallExpr
    assert call.lhs is ast.Ident
    assert (call.lhs as ast.Ident).name == 'helper'
}

fn test_register_generic_bindings_keeps_first_owner_for_duplicate_spec() {
    mut t := mono_test_transformer()
    t.env = types.Environment.new()
    bindings := {
        'T': types.Type(types.string_)
    }
    t.cur_generic_call_file_idx = 0
    t.register_generic_bindings('json2__Encoder__encode_value', bindings)
    t.cur_generic_call_file_idx = 1
    t.register_generic_bindings('json2__Encoder__encode_value', bindings)
    owner_key := generic_spec_owner_key('json2__Encoder__encode_value', bindings)
    owner := t.generic_spec_owner_file[owner_key] or { -1 }
    assert owner == 0
}

fn test_generic_call_concrete_return_type_prefers_substitution_over_stale_pos_type() {
    mut env := types.Environment.new()
    env.set_expr_type(77, types.Type(types.int_))
    mut t := mono_test_transformer()
    t.env = env
    t.generic_fn_decl_index['identity'] = ast.FnDecl{
        name: 'identity'
        typ:  ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'T'
                }),
            ]
            params:         [
                ast.Parameter{
                    name: 'x'
                    typ:  ast.Expr(ast.Ident{
                        name: 'T'
                    })
                },
            ]
            return_type:    ast.Expr(ast.Ident{
                name: 'T'
            })
        }
    }
    call := ast.Expr(ast.CallExpr{
        lhs:  ast.Expr(ast.Ident{
            name: 'identity'
        })
        args: [
            ast.Expr(ast.BasicLiteral{
                kind:  .number
                value: '0.0'
            }),
        ]
        pos:  token.Pos{
            id: 77
        }
    })
    ret := t.get_expr_type(call) or { panic('missing generic call return type') }
    assert ret is types.Primitive
    assert (ret as types.Primitive).props.has(types.Properties.float)
}

fn test_generic_call_concrete_return_type_finds_current_module_bare_call() {
    mut t := mono_test_transformer()
    t.cur_module = 'math'
    t.generic_fn_decl_index['math__identity'] = ast.FnDecl{
        name: 'identity'
        typ:  ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'T'
                }),
            ]
            params:         [
                ast.Parameter{
                    name: 'x'
                    typ:  ast.Expr(ast.Ident{
                        name: 'T'
                    })
                },
            ]
            return_type:    ast.Expr(ast.Ident{
                name: 'T'
            })
        }
    }
    call := ast.Expr(ast.CallExpr{
        lhs:  ast.Expr(ast.Ident{
            name: 'identity'
        })
        args: [
            ast.Expr(ast.BasicLiteral{
                kind:  .number
                value: '0.0'
            }),
        ]
    })
    ret := t.generic_call_concrete_return_type(call) or {
        panic('missing current-module generic return type')
    }
    assert ret is types.Primitive
    assert (ret as types.Primitive).props.has(types.Properties.float)
}

fn test_get_expr_type_prefers_local_decl_cache_over_stale_scope_type() {
    mut t := mono_test_transformer()
    mut scope := types.new_scope(unsafe { nil })
    scope.insert('ret', types.Type(types.int_))
    t.scope = scope
    t.local_decl_types['ret'] = types.Type(types.f64_)
    typ := t.get_expr_type(ast.Expr(ast.Ident{
        name: 'ret'
    })) or { panic('missing ident type') }
    assert typ.name() == 'f64'
}

fn test_clone_generic_type_name_selector_to_string_literal() {
    mut t := mono_test_transformer()
    expr := ast.Expr(ast.SelectorExpr{
        lhs: ast.Ident{
            name: 'T'
        }
        rhs: ast.Ident{
            name: 'name'
        }
        pos: token.Pos{
            id: 11
        }
    })
    out := t.clone_expr_with_bindings_and_fields(expr, {
        'T': types.Type(types.i64_)
    }, []CloneComptimeFieldCtx{})
    assert out is ast.StringLiteral
    assert (out as ast.StringLiteral).value == 'i64'
}

fn test_substitute_type_leaves_non_matching_named_type_alone() {
    bindings := {
        'T': types.Type(types.int_)
    }
    out := substitute_type(types.Type(types.NamedType('U')), bindings)
    assert out.name() == 'U'
}

// substitute_type: compound recursion

fn test_substitute_type_recurses_into_pointer_base() {
    bindings := {
        'T': types.Type(types.int_)
    }
    original := types.Type(types.Pointer{
        base_type: types.Type(types.NamedType('T'))
    })
    out := substitute_type(original, bindings)
    if out is types.Pointer {
        assert out.base_type.name() == 'int'
    } else {
        assert false, 'expected Pointer, got ${out.type_name()}'
    }
}

fn test_substitute_type_recurses_into_array_elem() {
    bindings := {
        'T': types.Type(types.int_)
    }
    original := types.Type(types.Array{
        elem_type: types.Type(types.NamedType('T'))
    })
    out := substitute_type(original, bindings)
    if out is types.Array {
        assert out.elem_type.name() == 'int'
    } else {
        assert false, 'expected Array, got ${out.type_name()}'
    }
}

fn test_substitute_type_recurses_into_map_key_and_value() {
    bindings := {
        'K': types.Type(types.string_)
        'V': types.Type(types.int_)
    }
    original := types.Type(types.Map{
        key_type:   types.Type(types.NamedType('K'))
        value_type: types.Type(types.NamedType('V'))
    })
    out := substitute_type(original, bindings)
    if out is types.Map {
        assert out.key_type.name() == 'string'
        assert out.value_type.name() == 'int'
    } else {
        assert false, 'expected Map, got ${out.type_name()}'
    }
}

fn test_substitute_type_recurses_into_option_base() {
    bindings := {
        'T': types.Type(types.int_)
    }
    original := types.Type(types.OptionType{
        base_type: types.Type(types.NamedType('T'))
    })
    out := substitute_type(original, bindings)
    if out is types.OptionType {
        assert out.base_type.name() == 'int'
    } else {
        assert false, 'expected OptionType, got ${out.type_name()}'
    }
}

fn test_substitute_type_recurses_into_nested_array_pointer() {
    bindings := {
        'T': types.Type(types.f64_)
    }
    original := types.Type(types.Array{
        elem_type: types.Type(types.Pointer{
            base_type: types.Type(types.NamedType('T'))
        })
    })
    out := substitute_type(original, bindings)
    if out is types.Array {
        elem := out.elem_type
        if elem is types.Pointer {
            assert elem.base_type.name() == 'f64'
        } else {
            assert false, 'expected nested Pointer, got ${elem.type_name()}'
        }
    } else {
        assert false, 'expected outer Array, got ${out.type_name()}'
    }
}

// substitute_type_in_expr: AST-level

fn test_substitute_type_in_expr_replaces_placeholder_ident() {
    mut t := mono_test_transformer()
    bindings := {
        'T': types.Type(types.int_)
    }
    expr := ast.Expr(ast.Ident{
        name: 'T'
    })
    out := t.substitute_type_in_expr(expr, bindings)
    if out is ast.Ident {
        assert out.name == 'int'
    } else {
        assert false, 'expected Ident, got ${out.type_name()}'
    }
}

fn test_substitute_type_in_expr_recurses_into_array_type() {
    mut t := mono_test_transformer()
    bindings := {
        'T': types.Type(types.int_)
    }
    expr := ast.Expr(ast.Type(ast.ArrayType{
        elem_type: ast.Expr(ast.Ident{
            name: 'T'
        })
    }))
    out := t.substitute_type_in_expr(expr, bindings)
    out_ty := out as ast.Type
    at := out_ty as ast.ArrayType
    elem := at.elem_type as ast.Ident
    assert elem.name == 'int'
}

fn test_substitute_type_in_expr_recurses_into_map_type() {
    mut t := mono_test_transformer()
    bindings := {
        'K': types.Type(types.string_)
        'V': types.Type(types.int_)
    }
    expr := ast.Expr(ast.Type(ast.MapType{
        key_type:   ast.Expr(ast.Ident{
            name: 'K'
        })
        value_type: ast.Expr(ast.Ident{
            name: 'V'
        })
    }))
    out := t.substitute_type_in_expr(expr, bindings)
    out_ty := out as ast.Type
    mt := out_ty as ast.MapType
    key := mt.key_type as ast.Ident
    val := mt.value_type as ast.Ident
    assert key.name == 'string'
    assert val.name == 'int'
}

fn test_substitute_type_in_expr_recurses_into_generic_index_type() {
    mut t := mono_test_transformer()
    bindings := {
        'T': types.Type(types.int_)
    }
    expr := ast.Expr(ast.GenericArgOrIndexExpr{
        lhs:  ast.Expr(ast.Ident{
            name: 'AtomicVal'
        })
        expr: ast.Expr(ast.Ident{
            name: 'T'
        })
    })
    out := t.substitute_type_in_expr(expr, bindings)
    gen := out as ast.GenericArgOrIndexExpr
    arg := gen.expr as ast.Ident
    assert arg.name == 'int'
}

// specialized_fn_name: matches cleanc's naming

fn test_specialized_fn_name_uses_all_placeholders_suffix_when_concrete_is_self() {
    t := mono_test_transformer()
    decl := ast.FnDecl{
        name: 'foo'
        typ:  ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'T'
                }),
            ]
        }
    }
    bindings := {
        'T': types.Type(types.NamedType('T'))
    }
    assert t.specialized_fn_name(decl, bindings) == 'foo_T'
}

fn test_specialized_fn_name_uses_concrete_token_suffix() {
    t := mono_test_transformer()
    decl := ast.FnDecl{
        name: 'foo'
        typ:  ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'T'
                }),
            ]
        }
    }
    bindings := {
        'T': types.Type(types.int_)
    }
    assert t.specialized_fn_name(decl, bindings) == 'foo_T_int'
}

fn test_specialized_fn_name_handles_multiple_params() {
    t := mono_test_transformer()
    decl := ast.FnDecl{
        name: 'pair'
        typ:  ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'K'
                }),
                ast.Expr(ast.Ident{
                    name: 'V'
                }),
            ]
        }
    }
    bindings := {
        'K': types.Type(types.string_)
        'V': types.Type(types.int_)
    }
    assert t.specialized_fn_name(decl, bindings) == 'pair_T_string_int'
}

fn test_clone_fn_decl_tracks_local_decl_types_for_interpolation_repair() {
    value_kind_type := types.Type(types.Enum{
        name: 'json2__ValueKind'
    })
    value_info_type := types.Type(types.Struct{
        name:   'json2__ValueInfo'
        fields: [
            types.Field{
                name: 'value_kind'
                typ:  value_kind_type
            },
        ]
    })
    node_type := types.Type(types.Struct{
        name:   'json2__Node'
        fields: [
            types.Field{
                name: 'value'
                typ:  value_info_type
            },
        ]
    })
    decoder_type := types.Type(types.Struct{
        name:   'json2__Decoder'
        fields: [
            types.Field{
                name: 'current_node'
                typ:  types.Type(types.Pointer{
                    base_type: node_type
                })
            },
        ]
    })
    mut t := mono_test_transformer()
    t.env = types.Environment.new()
    t.cur_module = 'json2'
    mut json2_scope := types.new_scope(unsafe { nil })
    json2_scope.insert_type('Decoder', decoder_type)
    json2_scope.insert_type('Node', node_type)
    json2_scope.insert_type('ValueInfo', value_info_type)
    t.cached_scopes['json2'] = json2_scope
    t.needed_str_fns = map[string]string{}
    t.needed_enum_str_fns = map[string]types.Enum{}
    value_kind_expr := ast.Expr(ast.SelectorExpr{
        lhs: ast.Expr(ast.Ident{
            name: 'string_info'
        })
        rhs: ast.Ident{
            name: 'value_kind'
        }
    })
    stale_arg := ast.Expr(ast.SelectorExpr{
        lhs: ast.Expr(ast.CallExpr{
            lhs:  ast.Expr(ast.Ident{
                name: 'string__str'
            })
            args: [value_kind_expr]
        })
        rhs: ast.Ident{
            name: 'str'
        }
    })
    decl := ast.FnDecl{
        name:      'decode_string'
        is_method: true
        receiver:  ast.Parameter{
            name: 'decoder'
            typ:  ast.Expr(ast.Ident{
                name: 'Decoder'
            })
        }
        typ:       ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'T'
                }),
            ]
        }
        stmts:     [
            ast.Stmt(ast.AssignStmt{
                op:  .decl_assign
                lhs: [
                    ast.Expr(ast.Ident{
                        name: 'string_info'
                    }),
                ]
                rhs: [
                    ast.Expr(ast.SelectorExpr{
                        lhs: ast.Expr(ast.SelectorExpr{
                            lhs: ast.Expr(ast.Ident{
                                name: 'decoder'
                            })
                            rhs: ast.Ident{
                                name: 'current_node'
                            }
                        })
                        rhs: ast.Ident{
                            name: 'value'
                        }
                    }),
                ]
            }),
            ast.Stmt(ast.ExprStmt{
                expr: ast.Expr(ast.StringInterLiteral{
                    values: [
                        "'Expected string, but got ",
                        "'",
                    ]
                    inters: [
                        ast.StringInter{
                            expr: stale_arg
                        },
                    ]
                })
            }),
        ]
    }
    cloned := t.clone_fn_decl_with_substitutions(decl, {
        'T': types.Type(types.string_)
    }, 'decode_string_T_string', 'json2', 'main')
    _ = t.env.get_fn_scope('main', 'Decoder__decode_string_T_string') or {
        panic('missing target module cloned function scope')
    }
    expr_stmt := cloned.stmts[1] as ast.ExprStmt
    lit := expr_stmt.expr as ast.StringInterLiteral
    repaired := lit.inters[0].expr
    assert repaired is ast.SelectorExpr
    repaired_call := (repaired as ast.SelectorExpr).lhs
    assert repaired_call is ast.CallExpr
    repaired_lhs := (repaired_call as ast.CallExpr).lhs
    assert repaired_lhs is ast.Ident
    assert (repaired_lhs as ast.Ident).name == 'json2__ValueKind__str'
}

fn test_moved_clone_qualifies_source_module_type_positions() {
    mut t := mono_test_transformer()
    t.env = types.Environment.new()
    mut json2_scope := types.new_scope(unsafe { nil })
    json2_scope.insert_type('DecoderOptions', types.Type(types.Struct{
        name: 'json2__DecoderOptions'
    }))
    json2_scope.insert_type('Decoder', types.Type(types.Struct{
        name: 'json2__Decoder'
    }))
    json2_scope.insert_type('StructFieldInfo', types.Type(types.Struct{
        name: 'json2__StructFieldInfo'
    }))
    t.cached_scopes['json2'] = json2_scope
    decl := ast.FnDecl{
        name:  'decode'
        typ:   ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'T'
                }),
            ]
            params:         [
                ast.Parameter{
                    name: 'val'
                    typ:  ast.Expr(ast.Ident{
                        name: 'string'
                    })
                },
                ast.Parameter{
                    name: 'params'
                    typ:  ast.Expr(ast.Ident{
                        name: 'DecoderOptions'
                    })
                },
            ]
            return_type:    ast.Expr(ast.Type(ast.ResultType{
                base_type: ast.Expr(ast.Ident{
                    name: 'T'
                })
            }))
        }
        stmts: [
            ast.Stmt(ast.AssignStmt{
                op:  .decl_assign
                lhs: [
                    ast.Expr(ast.Ident{
                        name: 'decoder'
                    }),
                ]
                rhs: [
                    ast.Expr(ast.InitExpr{
                        typ: ast.Expr(ast.Ident{
                            name: 'Decoder'
                        })
                    }),
                ]
            }),
            ast.Stmt(ast.ExprStmt{
                expr: ast.Expr(ast.ArrayInitExpr{
                    typ: ast.Expr(ast.Type(ast.ArrayType{
                        elem_type: ast.Expr(ast.Ident{
                            name: 'StructFieldInfo'
                        })
                    }))
                })
            }),
        ]
    }
    mut cloned := t.clone_fn_decl_with_substitutions(decl, {
        'T': types.Type(types.Struct{
            name: 'api__ApiBranchCount'
        })
    }, 'json2__decode_T_api_ApiBranchCount', 'json2', 'main')
    cloned = t.qualify_moved_clone_source_module_types(cloned, 'json2')
    options_type := cloned.typ.params[1].typ as ast.Ident
    assert options_type.name == 'json2__DecoderOptions'
    assign := cloned.stmts[0] as ast.AssignStmt
    init := assign.rhs[0] as ast.InitExpr
    init_type := init.typ as ast.Ident
    assert init_type.name == 'json2__Decoder'
    expr_stmt := cloned.stmts[1] as ast.ExprStmt
    array_init := expr_stmt.expr as ast.ArrayInitExpr
    array_type := array_init.typ as ast.Type
    array := array_type as ast.ArrayType
    elem := array.elem_type as ast.Ident
    assert elem.name == 'json2__StructFieldInfo'
}

fn test_moved_clone_qualifies_source_module_generic_function_value() {
    mut t := mono_test_transformer()
    handler_decl := ast.FnDecl{
        name: 'parallel_request_handler'
        typ:  ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'A'
                }),
                ast.Expr(ast.Ident{
                    name: 'X'
                }),
            ]
        }
    }
    t.generic_fn_decl_index['parallel_request_handler'] = handler_decl
    t.generic_fn_decl_index['json2__parallel_request_handler'] = handler_decl
    decl := ast.FnDecl{
        name:  'run_new'
        typ:   ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'A'
                }),
                ast.Expr(ast.Ident{
                    name: 'X'
                }),
            ]
        }
        stmts: [
            ast.Stmt(ast.ExprStmt{
                expr: ast.Expr(ast.InitExpr{
                    typ:    ast.Expr(ast.Ident{
                        name: 'ServerConfig'
                    })
                    fields: [
                        ast.FieldInit{
                            name:  'handler'
                            value: ast.Expr(ast.GenericArgs{
                                lhs:  ast.Expr(ast.Ident{
                                    name: 'parallel_request_handler'
                                })
                                args: [
                                    ast.Expr(ast.Ident{
                                        name: 'A'
                                    }),
                                    ast.Expr(ast.Ident{
                                        name: 'X'
                                    }),
                                ]
                            })
                        },
                    ]
                })
            }),
        ]
    }
    mut cloned := t.clone_fn_decl_with_substitutions(decl, {
        'A': types.Type(types.Struct{
            name: 'main__App'
        })
        'X': types.Type(types.Struct{
            name: 'main__Context'
        })
    }, 'json2__run_new_T_App_Context', 'json2', 'main')
    cloned = t.qualify_moved_clone_source_module_types(cloned, 'json2')
    expr_stmt := cloned.stmts[0] as ast.ExprStmt
    init := expr_stmt.expr as ast.InitExpr
    handler := init.fields[0].value as ast.Ident
    assert handler.name == 'json2__parallel_request_handler_T_main_App_main_Context'
}

fn test_moved_clone_qualifies_source_module_generic_function_value_index_expr() {
    mut t := mono_test_transformer()
    handler_decl := ast.FnDecl{
        name: 'parallel_request_handler'
        typ:  ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'A'
                }),
                ast.Expr(ast.Ident{
                    name: 'X'
                }),
            ]
        }
    }
    t.generic_fn_decl_index['parallel_request_handler'] = handler_decl
    t.generic_fn_decl_index['json2__parallel_request_handler'] = handler_decl
    decl := ast.FnDecl{
        name:  'run_new'
        typ:   ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'A'
                }),
                ast.Expr(ast.Ident{
                    name: 'X'
                }),
            ]
        }
        stmts: [
            ast.Stmt(ast.ExprStmt{
                expr: ast.Expr(ast.InitExpr{
                    typ:    ast.Expr(ast.Ident{
                        name: 'ServerConfig'
                    })
                    fields: [
                        ast.FieldInit{
                            name:  'handler'
                            value: ast.Expr(ast.IndexExpr{
                                lhs:  ast.Expr(ast.GenericArgOrIndexExpr{
                                    lhs:  ast.Expr(ast.Ident{
                                        name: 'parallel_request_handler'
                                    })
                                    expr: ast.Expr(ast.Ident{
                                        name: 'A'
                                    })
                                })
                                expr: ast.Expr(ast.Ident{
                                    name: 'X'
                                })
                            })
                        },
                    ]
                })
            }),
        ]
    }
    mut cloned := t.clone_fn_decl_with_substitutions(decl, {
        'A': types.Type(types.Struct{
            name: 'main__App'
        })
        'X': types.Type(types.Struct{
            name: 'main__Context'
        })
    }, 'json2__run_new_T_App_Context', 'json2', 'main')
    cloned = t.qualify_moved_clone_source_module_types(cloned, 'json2')
    expr_stmt := cloned.stmts[0] as ast.ExprStmt
    init := expr_stmt.expr as ast.InitExpr
    handler := init.fields[0].value as ast.Ident
    assert handler.name == 'json2__parallel_request_handler_T_main_App_main_Context'
}

fn test_collect_generic_struct_field_type_resolves_prefix_pointer_generic_arg() {
    value_kind_type := types.Type(types.Enum{
        name: 'json2__ValueKind'
    })
    value_info_type := types.Type(types.Struct{
        name:   'json2__ValueInfo'
        fields: [
            types.Field{
                name: 'value_kind'
                typ:  value_kind_type
            },
        ]
    })
    node_type := types.Type(types.Struct{
        name:           'json2__Node'
        generic_params: ['T']
        fields:         [
            types.Field{
                name: 'value'
                typ:  types.Type(types.NamedType('T'))
            },
        ]
    })
    mut t := mono_test_transformer()
    t.env = types.Environment.new()
    t.cur_module = 'json2'
    mut json2_scope := types.new_scope(unsafe { nil })
    json2_scope.insert_type('Node', node_type)
    json2_scope.insert_type('ValueInfo', value_info_type)
    t.cached_scopes['json2'] = json2_scope
    t.collect_struct_decl_generic_field_types(ast.StructDecl{
        name:   'Decoder'
        fields: [
            ast.FieldDecl{
                name: 'current_node'
                typ:  ast.Expr(ast.PrefixExpr{
                    op:   .amp
                    expr: ast.Expr(ast.GenericArgOrIndexExpr{
                        lhs:  ast.Expr(ast.Ident{
                            name: 'Node'
                        })
                        expr: ast.Expr(ast.Ident{
                            name: 'ValueInfo'
                        })
                    })
                })
            },
        ]
    }, 'json2')
    field_typ := t.lookup_struct_field_generic_decl_type('json2__Decoder', 'current_node') or {
        panic('missing concrete current_node type')
    }
    assert field_typ is types.Pointer
    node_concrete := (field_typ as types.Pointer).base_type
    assert node_concrete is types.Struct
    value_field := struct_field_by_name(node_concrete as types.Struct, 'value') or {
        panic('missing Node.value field')
    }
    assert value_field.typ.name() == 'json2__ValueInfo'
}

// clone_fn_decl_with_substitutions: end-to-end on a trivial generic fn

fn test_clone_fn_decl_renames_and_substitutes_param_and_return_types() {
    mut t := mono_test_transformer()
    bindings := {
        'T': types.Type(types.int_)
    }
    body_pos := token.Pos{
        id: 1
    }
    decl := ast.FnDecl{
        name:  'identity'
        typ:   ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'T'
                }),
            ]
            params:         [
                ast.Parameter{
                    name: 'x'
                    typ:  ast.Expr(ast.Ident{
                        name: 'T'
                    })
                },
            ]
            return_type:    ast.Expr(ast.Ident{
                name: 'T'
            })
        }
        stmts: [
            ast.Stmt(ast.ReturnStmt{
                exprs: [
                    ast.Expr(ast.Ident{
                        name: 'x'
                        pos:  body_pos
                    }),
                ]
            }),
        ]
    }
    cloned := t.clone_fn_decl_with_substitutions(decl, bindings, 'identity_T_int', '', '')
    assert cloned.name == 'identity_T_int'
    assert cloned.typ.generic_params.len == 0
    assert cloned.typ.params.len == 1
    param_typ := cloned.typ.params[0].typ as ast.Ident
    assert param_typ.name == 'int'
    ret_typ := cloned.typ.return_type as ast.Ident
    assert ret_typ.name == 'int'
    // Body is preserved structurally (x is a value identifier, not a type — stays 'x')
    assert cloned.stmts.len == 1
    if cloned.stmts[0] is ast.ReturnStmt {
        ret_stmt := cloned.stmts[0] as ast.ReturnStmt
        ret_ident := ret_stmt.exprs[0] as ast.Ident
        assert ret_ident.name == 'x'
    } else {
        assert false, 'expected ReturnStmt'
    }
}

fn test_clone_fn_decl_substitutes_inside_array_param_type() {
    mut t := mono_test_transformer()
    bindings := {
        'T': types.Type(types.int_)
    }
    decl := ast.FnDecl{
        name: 'first'
        typ:  ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'T'
                }),
            ]
            params:         [
                ast.Parameter{
                    name: 'arr'
                    typ:  ast.Expr(ast.Type(ast.ArrayType{
                        elem_type: ast.Expr(ast.Ident{
                            name: 'T'
                        })
                    }))
                },
            ]
            return_type:    ast.Expr(ast.Ident{
                name: 'T'
            })
        }
    }
    cloned := t.clone_fn_decl_with_substitutions(decl, bindings, 'first_T_int', '', '')
    assert cloned.name == 'first_T_int'
    param_typ := cloned.typ.params[0].typ as ast.Type
    arr_typ := param_typ as ast.ArrayType
    elem := arr_typ.elem_type as ast.Ident
    assert elem.name == 'int'
}

fn test_clone_fn_decl_registers_array_index_decl_type_in_clone_scope() {
    mut t := mono_test_transformer()
    value_pos := token.Pos{
        id: 801
    }
    index_pos := token.Pos{
        id: 802
    }
    first_lhs_pos := token.Pos{
        id: 803
    }
    t.env.set_expr_type(value_pos.id, types.Type(types.Array{
        elem_type: types.Type(types.f64_)
    }))
    t.env.set_expr_type(index_pos.id, types.Type(types.f64_))
    decl := ast.FnDecl{
        name:  'first'
        typ:   ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'T'
                }),
            ]
            params:         [
                ast.Parameter{
                    name: 'value'
                    typ:  ast.Expr(ast.Type(ast.ArrayType{
                        elem_type: ast.Expr(ast.Ident{
                            name: 'T'
                        })
                    }))
                },
            ]
        }
        stmts: [
            ast.Stmt(ast.AssignStmt{
                op:  .decl_assign
                lhs: [
                    ast.Expr(ast.Ident{
                        name: 'first'
                        pos:  first_lhs_pos
                    }),
                ]
                rhs: [
                    ast.Expr(ast.IndexExpr{
                        lhs:  ast.Expr(ast.Ident{
                            name: 'value'
                            pos:  value_pos
                        })
                        expr: ast.Expr(ast.BasicLiteral{
                            kind:  .number
                            value: '0'
                        })
                        pos:  index_pos
                    }),
                ]
            }),
        ]
    }
    cloned := t.clone_fn_decl_with_substitutions(decl, {
        'T': types.Type(types.string_)
    }, 'first_T_string', 'orm', 'main')
    scope := t.env.get_fn_scope('orm', 'first_T_string') or {
        panic('missing cloned function scope')
    }
    first_type := scope.lookup_var_type('first') or { panic('missing first type') }
    assert first_type is types.String
    stmt := cloned.stmts[0] as ast.AssignStmt
    lhs := stmt.lhs[0] as ast.Ident
    lhs_type := t.synth_types[lhs.pos.id] or { panic('missing first synth type') }
    assert lhs_type is types.String
}

fn test_clone_fn_decl_registers_nested_array_index_decl_type_in_clone_scope() {
    mut t := mono_test_transformer()
    value_pos := token.Pos{
        id: 821
    }
    index_pos := token.Pos{
        id: 822
    }
    item_lhs_pos := token.Pos{
        id: 823
    }
    t.env.set_expr_type(value_pos.id, types.Type(types.Array{
        elem_type: types.Type(types.f64_)
    }))
    t.env.set_expr_type(index_pos.id, types.Type(types.f64_))
    decl := ast.FnDecl{
        name:  'first_nested'
        typ:   ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'T'
                }),
            ]
            params:         [
                ast.Parameter{
                    name: 'value'
                    typ:  ast.Expr(ast.Type(ast.ArrayType{
                        elem_type: ast.Expr(ast.Ident{
                            name: 'T'
                        })
                    }))
                },
            ]
        }
        stmts: [
            ast.Stmt(ast.ForStmt{
                stmts: [
                    ast.Stmt(ast.AssignStmt{
                        op:  .decl_assign
                        lhs: [
                            ast.Expr(ast.Ident{
                                name: 'item'
                                pos:  item_lhs_pos
                            }),
                        ]
                        rhs: [
                            ast.Expr(ast.IndexExpr{
                                lhs:  ast.Expr(ast.Ident{
                                    name: 'value'
                                    pos:  value_pos
                                })
                                expr: ast.Expr(ast.BasicLiteral{
                                    kind:  .number
                                    value: '0'
                                })
                                pos:  index_pos
                            }),
                        ]
                    }),
                ]
            }),
        ]
    }
    cloned := t.clone_fn_decl_with_substitutions(decl, {
        'T': types.Type(types.string_)
    }, 'first_nested_T_string', 'orm', 'main')
    scope := t.env.get_fn_scope('orm', 'first_nested_T_string') or {
        panic('missing cloned function scope')
    }
    item_type := scope.lookup_var_type('item') or { panic('missing item type') }
    assert item_type is types.String
    for_stmt := cloned.stmts[0] as ast.ForStmt
    stmt := for_stmt.stmts[0] as ast.AssignStmt
    lhs := stmt.lhs[0] as ast.Ident
    lhs_type := t.synth_types[lhs.pos.id] or { panic('missing item synth type') }
    assert lhs_type is types.String
}

fn test_clone_fn_decl_preserves_unrelated_stmts() {
    mut t := mono_test_transformer()
    bindings := {
        'T': types.Type(types.int_)
    }
    decl := ast.FnDecl{
        name:  'noop'
        typ:   ast.FnType{
            generic_params: [
                ast.Expr(ast.Ident{
                    name: 'T'
                }),
            ]
        }
        stmts: [
            ast.Stmt(ast.ExprStmt{
                expr: ast.Expr(ast.BasicLiteral{
                    kind:  .number
                    value: '42'
                })
            }),
        ]
    }
    cloned := t.clone_fn_decl_with_substitutions(decl, bindings, 'noop_T_int', '', '')
    assert cloned.stmts.len == 1
    es := cloned.stmts[0] as ast.ExprStmt
    lit := es.expr as ast.BasicLiteral
    assert lit.value == '42'
}