// 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: macos
module transformer

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

// Helper to create a minimal transformer for testing
fn create_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{}
        local_decl_types:            map[string]types.Type{}
    }
}

// Helper to create a transformer with a scope containing variable types
fn create_transformer_with_vars(vars map[string]types.Type) &Transformer {
    env := &types.Environment{}
    mut scope := types.new_scope(unsafe { nil })
    for name, typ in vars {
        scope.insert(name, value_object_from_type(typ))
    }
    return &Transformer{
        pref:                        &vpref.Preferences{}
        env:                         unsafe { env }
        scope:                       scope
        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{}
        local_decl_types:            map[string]types.Type{}
    }
}

fn test_value_object_from_type_stores_value_symbol_type() {
    obj := value_object_from_type(types.Type(types.int_))
    assert obj is types.TypeObject
    assert obj.typ() is types.Primitive
}

fn test_worker_clone_owns_mutable_maps() {
    prefs := &vpref.Preferences{}
    env := types.Environment.new()
    mut transformer := Transformer.new_with_pref(env, prefs)
    transformer.synth_pos_counter = -73
    scope := types.new_scope(unsafe { nil })
    transformer.elided_fns = {
        'main__skipped': true
    }
    transformer.cached_scopes = {
        'main': scope
    }
    transformer.cached_fn_scopes = {
        'main__known': scope
    }
    transformer.cached_method_keys = ['main__Foo']
    transformer.generic_fn_value_names = {
        'handler': true
    }

    mut worker := transformer.new_worker_clone(1)
    assert worker.next_synth_pos().id == -100073
    worker.elided_fns['main__worker_skipped'] = true
    worker.cached_scopes['worker'] = scope
    worker.cached_fn_scopes['main__worker'] = scope
    worker.cached_method_keys << 'main__Bar'
    worker.generic_fn_value_names['worker_handler'] = true

    assert 'main__worker_skipped' !in transformer.elided_fns
    assert 'worker' !in transformer.cached_scopes
    assert 'main__worker' !in transformer.cached_fn_scopes
    assert transformer.cached_method_keys == ['main__Foo']
    assert 'worker_handler' !in transformer.generic_fn_value_names

    transformer.merge_worker(worker)
    assert transformer.elided_fns['main__worker_skipped']
    assert transformer.cached_fn_scopes['main__worker'] == scope
}

fn transform_code_for_test(code string) []ast.File {
    prefs := &vpref.Preferences{
        backend:     .cleanc
        no_parallel: true
    }
    return transform_code_with_prefs_for_test(code, prefs)
}

fn transform_code_with_prefs_for_test(code string, prefs &vpref.Preferences) []ast.File {
    tmp_file := '/tmp/v2_transformer_test_${os.getpid()}.v'
    os.write_file(tmp_file, code) or { panic('failed to write temp file') }
    defer {
        os.rm(tmp_file) or {}
    }
    mut file_set := token.FileSet.new()
    mut par := parser.Parser.new(prefs)
    files := par.parse_files([tmp_file], mut file_set)
    mut env := types.Environment.new()
    mut checker := types.Checker.new(prefs, file_set, env)
    checker.check_files(files)
    mut transformer := Transformer.new_with_pref(env, prefs)
    return transformer.transform_files(files)
}

fn transform_code_with_env_for_test(code string) (&types.Environment, []ast.File) {
    tmp_file := '/tmp/v2_transformer_env_test_${os.getpid()}.v'
    os.write_file(tmp_file, code) or { panic('failed to write temp file') }
    defer {
        os.rm(tmp_file) or {}
    }
    prefs := &vpref.Preferences{
        backend:     .cleanc
        no_parallel: true
    }
    mut file_set := token.FileSet.new()
    mut par := parser.Parser.new(prefs)
    files := par.parse_files([tmp_file], mut file_set)
    mut env := types.Environment.new()
    mut checker := types.Checker.new(prefs, file_set, env)
    checker.check_files(files)
    mut transformer := Transformer.new_with_pref(env, prefs)
    transformed := transformer.transform_files(files)
    return env, transformed
}

struct TestSource {
    rel  string
    code string
}

fn transform_sources_for_test(sources []TestSource) []ast.File {
    tmp_dir := os.join_path(os.temp_dir(), 'v2_transformer_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:     .cleanc
        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 transformer := Transformer.new_with_pref(env, prefs)
    return transformer.transform_files(files)
}

fn transform_sources_with_env_for_test(sources []TestSource) (&types.Environment, []ast.File) {
    tmp_dir := os.join_path(os.temp_dir(), 'v2_transformer_sources_env_${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:     .cleanc
        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 transformer := Transformer.new_with_pref(env, prefs)
    transformed := transformer.transform_files(files)
    return env, transformed
}

fn ident_name_from_expr_for_test(expr ast.Expr) ?string {
    if expr is ast.Ident {
        return expr.name
    }
    if expr is ast.ModifierExpr && expr.expr is ast.Ident {
        return expr.expr.name
    }
    return none
}

fn test_sort_selector_path_after_root_keeps_nested_fields() {
    t := create_test_transformer()
    expr := ast.Expr(ast.SelectorExpr{
        lhs: ast.Expr(ast.SelectorExpr{
            lhs: ast.Expr(ast.Ident{
                name: 'a'
            })
            rhs: ast.Ident{
                name: 'path'
            }
        })
        rhs: ast.Ident{
            name: 'len'
        }
    })
    path := t.selector_path_after_root(expr, 'a') or { panic('missing selector path') }

    assert path.len == 2
    assert path[0] == 'path'
    assert path[1] == 'len'
}

fn test_get_expr_type_selector_prefers_struct_field_over_stale_pos_type() {
    mut env := types.Environment.new()
    env.set_expr_type(91, types.string_)
    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
            },
        ]
    })
    mut scope := types.new_scope(unsafe { nil })
    scope.insert('struct_info', value_object_from_type(value_info_type))
    mut t := Transformer{
        pref:             &vpref.Preferences{}
        env:              unsafe { env }
        scope:            scope
        local_decl_types: map[string]types.Type{}
    }
    typ := t.get_expr_type(ast.SelectorExpr{
        lhs: ast.Ident{
            name: 'struct_info'
        }
        rhs: ast.Ident{
            name: 'value_kind'
        }
        pos: token.Pos{
            id: 91
        }
    }) or { panic('missing selector type') }
    assert typ is types.Enum
    assert (typ as types.Enum).name == 'json2__ValueKind'
}

fn test_get_expr_type_selector_prefers_struct_field_over_stale_synth_type() {
    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
            },
        ]
    })
    mut scope := types.new_scope(unsafe { nil })
    scope.insert('struct_info', value_object_from_type(value_info_type))
    mut t := Transformer{
        pref:             &vpref.Preferences{}
        env:              unsafe { types.Environment.new() }
        scope:            scope
        local_decl_types: map[string]types.Type{}
    }
    pos := token.Pos{
        id: 92
    }
    t.register_synth_type(pos, types.Type(types.string_))
    typ := t.get_expr_type(ast.SelectorExpr{
        lhs: ast.Ident{
            name: 'struct_info'
        }
        rhs: ast.Ident{
            name: 'value_kind'
        }
        pos: pos
    }) or { panic('missing selector type') }
    assert typ is types.Enum
    assert (typ as types.Enum).name == 'json2__ValueKind'
}

fn test_string_interpolation_prefers_declared_selector_type_over_stale_string_pos() {
    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
            },
        ]
    })
    mut env := types.Environment.new()
    env.set_expr_type(93, types.Type(types.string_))
    mut scope := types.new_scope(unsafe { nil })
    scope.insert('struct_info', value_object_from_type(value_info_type))
    mut t := Transformer{
        pref:                &vpref.Preferences{}
        env:                 unsafe { env }
        scope:               scope
        local_decl_types:    map[string]types.Type{}
        needed_str_fns:      map[string]string{}
        needed_enum_str_fns: map[string]types.Enum{}
        synth_types:         map[int]types.Type{}
    }
    inter_expr := ast.Expr(ast.SelectorExpr{
        lhs: ast.Ident{
            name: 'struct_info'
        }
        rhs: ast.Ident{
            name: 'value_kind'
        }
        pos: token.Pos{
            id: 93
        }
    })
    inter := ast.StringInter{
        expr: inter_expr
    }
    assert t.resolve_sprintf_format(inter) == '%s'
    arg := t.transform_sprintf_arg(inter)
    assert arg is ast.SelectorExpr
    call := (arg as ast.SelectorExpr).lhs
    assert call is ast.CallExpr
    lhs := (call as ast.CallExpr).lhs
    assert lhs is ast.Ident
    assert (lhs as ast.Ident).name == 'json2__ValueKind__str'

    stale_arg := ast.Expr(ast.SelectorExpr{
        lhs: ast.Expr(ast.CallExpr{
            lhs:  ast.Ident{
                name: 'string__str'
            }
            args: [inter_expr]
            pos:  token.Pos{
                id: 94
            }
        })
        rhs: ast.Ident{
            name: 'str'
        }
        pos: token.Pos{
            id: 95
        }
    })
    lit := t.transform_string_inter_literal(ast.StringInterLiteral{
        values: ["'Expected object, but got ", "'"]
        inters: [
            ast.StringInter{
                expr: stale_arg
            },
        ]
    })
    assert lit is ast.StringInterLiteral
    repaired := (lit as ast.StringInterLiteral).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'

    cloned := t.clone_expr_with_bindings_and_fields(ast.Expr(ast.StringInterLiteral{
        values: ["'Expected object, but got ", "'"]
        inters: [
            ast.StringInter{
                expr: stale_arg
            },
        ]
    }), map[string]types.Type{}, []CloneComptimeFieldCtx{})
    assert cloned is ast.StringInterLiteral
    cloned_arg := (cloned as ast.StringInterLiteral).inters[0].expr
    assert cloned_arg is ast.SelectorExpr
    cloned_call := (cloned_arg as ast.SelectorExpr).lhs
    assert cloned_call is ast.CallExpr
    cloned_lhs := (cloned_call as ast.CallExpr).lhs
    assert cloned_lhs is ast.Ident
    assert (cloned_lhs as ast.Ident).name == 'json2__ValueKind__str'
}

fn collect_call_names_from_stmt(stmt ast.Stmt, mut names []string) {
    match stmt {
        ast.AssignStmt {
            for expr in stmt.lhs {
                collect_call_names_from_expr(expr, mut names)
            }
            for expr in stmt.rhs {
                collect_call_names_from_expr(expr, mut names)
            }
        }
        ast.AssertStmt {
            collect_call_names_from_expr(stmt.expr, mut names)
            collect_call_names_from_expr(stmt.extra, mut names)
        }
        ast.BlockStmt {
            for nested in stmt.stmts {
                collect_call_names_from_stmt(nested, mut names)
            }
        }
        ast.ComptimeStmt {
            collect_call_names_from_stmt(stmt.stmt, mut names)
        }
        ast.DeferStmt {
            for nested in stmt.stmts {
                collect_call_names_from_stmt(nested, mut names)
            }
        }
        ast.ExprStmt {
            collect_call_names_from_expr(stmt.expr, mut names)
        }
        ast.ForInStmt {
            collect_call_names_from_expr(stmt.key, mut names)
            collect_call_names_from_expr(stmt.value, mut names)
            collect_call_names_from_expr(stmt.expr, mut names)
        }
        ast.ForStmt {
            collect_call_names_from_stmt(stmt.init, mut names)
            collect_call_names_from_expr(stmt.cond, mut names)
            collect_call_names_from_stmt(stmt.post, mut names)
            for nested in stmt.stmts {
                collect_call_names_from_stmt(nested, mut names)
            }
        }
        ast.LabelStmt {
            collect_call_names_from_stmt(stmt.stmt, mut names)
        }
        ast.ReturnStmt {
            for expr in stmt.exprs {
                collect_call_names_from_expr(expr, mut names)
            }
        }
        else {}
    }
}

fn collect_call_names_from_expr(expr ast.Expr, mut names []string) {
    match expr {
        ast.ArrayInitExpr {
            collect_call_names_from_expr(expr.init, mut names)
            collect_call_names_from_expr(expr.cap, mut names)
            collect_call_names_from_expr(expr.len, mut names)
            for item in expr.exprs {
                collect_call_names_from_expr(item, mut names)
            }
        }
        ast.AsCastExpr {
            collect_call_names_from_expr(expr.expr, mut names)
        }
        ast.AssocExpr {
            collect_call_names_from_expr(expr.expr, mut names)
            for field in expr.fields {
                collect_call_names_from_expr(field.value, mut names)
            }
        }
        ast.CallExpr {
            if expr.lhs is ast.Ident {
                names << expr.lhs.name
            }
            collect_call_names_from_expr(expr.lhs, mut names)
            for arg in expr.args {
                collect_call_names_from_expr(arg, mut names)
            }
        }
        ast.CallOrCastExpr {
            collect_call_names_from_expr(expr.lhs, mut names)
            collect_call_names_from_expr(expr.expr, mut names)
        }
        ast.CastExpr {
            collect_call_names_from_expr(expr.expr, mut names)
        }
        ast.FieldInit {
            collect_call_names_from_expr(expr.value, mut names)
        }
        ast.FnLiteral {
            for nested in expr.stmts {
                collect_call_names_from_stmt(nested, mut names)
            }
        }
        ast.GenericArgOrIndexExpr {
            collect_call_names_from_expr(expr.lhs, mut names)
            collect_call_names_from_expr(expr.expr, mut names)
        }
        ast.GenericArgs {
            collect_call_names_from_expr(expr.lhs, mut names)
            for arg in expr.args {
                collect_call_names_from_expr(arg, mut names)
            }
        }
        ast.IfExpr {
            collect_call_names_from_expr(expr.cond, mut names)
            for nested in expr.stmts {
                collect_call_names_from_stmt(nested, mut names)
            }
            collect_call_names_from_expr(expr.else_expr, mut names)
        }
        ast.IndexExpr {
            collect_call_names_from_expr(expr.lhs, mut names)
            collect_call_names_from_expr(expr.expr, mut names)
        }
        ast.InfixExpr {
            collect_call_names_from_expr(expr.lhs, mut names)
            collect_call_names_from_expr(expr.rhs, mut names)
        }
        ast.InitExpr {
            for field in expr.fields {
                collect_call_names_from_expr(field.value, mut names)
            }
        }
        ast.LambdaExpr {
            collect_call_names_from_expr(expr.expr, mut names)
        }
        ast.LockExpr {
            for nested in expr.stmts {
                collect_call_names_from_stmt(nested, mut names)
            }
        }
        ast.MapInitExpr {
            for key in expr.keys {
                collect_call_names_from_expr(key, mut names)
            }
            for val in expr.vals {
                collect_call_names_from_expr(val, mut names)
            }
        }
        ast.MatchExpr {
            collect_call_names_from_expr(expr.expr, mut names)
            for branch in expr.branches {
                for cond in branch.cond {
                    collect_call_names_from_expr(cond, mut names)
                }
                for nested in branch.stmts {
                    collect_call_names_from_stmt(nested, mut names)
                }
            }
        }
        ast.ModifierExpr {
            collect_call_names_from_expr(expr.expr, mut names)
        }
        ast.OrExpr {
            collect_call_names_from_expr(expr.expr, mut names)
            for nested in expr.stmts {
                collect_call_names_from_stmt(nested, mut names)
            }
        }
        ast.ParenExpr {
            collect_call_names_from_expr(expr.expr, mut names)
        }
        ast.PostfixExpr {
            collect_call_names_from_expr(expr.expr, mut names)
        }
        ast.PrefixExpr {
            collect_call_names_from_expr(expr.expr, mut names)
        }
        ast.RangeExpr {
            collect_call_names_from_expr(expr.start, mut names)
            collect_call_names_from_expr(expr.end, mut names)
        }
        ast.SelectExpr {
            collect_call_names_from_stmt(expr.stmt, mut names)
            for nested in expr.stmts {
                collect_call_names_from_stmt(nested, mut names)
            }
            collect_call_names_from_expr(expr.next, mut names)
        }
        ast.SelectorExpr {
            collect_call_names_from_expr(expr.lhs, mut names)
        }
        ast.StringInterLiteral {
            for inter in expr.inters {
                collect_call_names_from_expr(inter.expr, mut names)
                collect_call_names_from_expr(inter.format_expr, mut names)
            }
        }
        ast.Tuple {
            for item in expr.exprs {
                collect_call_names_from_expr(item, mut names)
            }
        }
        ast.UnsafeExpr {
            for nested in expr.stmts {
                collect_call_names_from_stmt(nested, mut names)
            }
        }
        else {}
    }
}

fn 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 {
                    collect_call_names_from_stmt(nested, mut names)
                }
            }
        }
    }
    return names
}

fn test_println_rune_lowers_to_rune_str_call() {
    mut t := create_transformer_with_vars({
        'r': types.Type(types.rune_)
    })
    out := t.transform_call_expr(ast.CallExpr{
        lhs:  ast.Ident{
            name: 'println'
        }
        args: [ast.Expr(ast.Ident{
            name: 'r'
        })]
    })
    assert out is ast.CallExpr
    call := out as ast.CallExpr
    assert call.args.len == 1
    assert call.args[0] is ast.CallExpr
    str_call := call.args[0] as ast.CallExpr
    assert str_call.lhs is ast.Ident
    assert (str_call.lhs as ast.Ident).name == 'rune__str'
    assert 'rune__str' in t.needed_str_fns
}

fn test_println_i64_call_or_cast_lowers_to_i64_str_call() {
    mut t := create_test_transformer()
    out := t.transform_call_expr(ast.CallExpr{
        lhs:  ast.Ident{
            name: 'println'
        }
        args: [
            ast.Expr(ast.CallOrCastExpr{
                lhs:  ast.Ident{
                    name: 'i64'
                }
                expr: ast.BasicLiteral{
                    kind:  .number
                    value: '4294967296'
                }
            }),
        ]
    })
    assert out is ast.CallExpr
    call := out as ast.CallExpr
    assert call.args.len == 1
    assert call.args[0] is ast.CallExpr
    str_call := call.args[0] as ast.CallExpr
    assert str_call.lhs is ast.Ident
    assert (str_call.lhs as ast.Ident).name == 'i64__str'
    assert 'i64__str' in t.needed_str_fns
}

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

fn test_transform_generic_call_uses_sumtype_match_smartcast_for_inference() {
    files := transform_code_for_test('
struct Point {
    x int
}

type Primitive = []int | []string | []Point | bool | int | string | Point

fn wrap_first[T](values []T) Primitive {
    return Primitive(values[0])
}

fn check(value Primitive) {
    match value {
        []int {
            _ := wrap_first(value)
        }
        []string {
            _ := wrap_first(value)
        }
        []Point {
            _ := wrap_first(value)
        }
        else {}
    }
}
')
    names := call_names_for_fn(files, 'check')
    assert 'wrap_first_T_int' in names
    assert 'wrap_first_T_string' in names
    assert 'wrap_first_T_Point' in names
    assert 'wrap_first' !in names
}

fn test_transform_generic_receiver_methods_use_concrete_specializations() {
    files := transform_sources_for_test([
        TestSource{
            rel:  'x/json2/decode.v'
            code: '
module json2

struct ValueInfo {
    x int
}

struct Node[T] {
mut:
    value T
    next  &Node[T] = unsafe { nil }
}

struct Decoder {
mut:
    values_info LinkedList[ValueInfo]
}

struct LinkedList[T] {
mut:
    head &Node[T] = unsafe { nil }
    tail &Node[T] = unsafe { nil }
    len  int
}

fn (mut list LinkedList[T]) push(value T) {
    _ = value
}

fn (list &LinkedList[T]) last() &T {
    return &list.tail.value
}
'
        },
        TestSource{
            rel:  'x/json2/check.v'
            code: '
module json2

fn (mut checker Decoder) check() {
    mut actual_value_info_pointer := unsafe { nil }
    checker.values_info.push(ValueInfo{})
    actual_value_info_pointer = checker.values_info.last()
    _ = actual_value_info_pointer
}
'
        },
    ])
    names := call_names_for_fn(files, 'check')
    assert names.any(it.contains('json2__LinkedList__push_T_') && it.contains('json2_ValueInfo')), 'expected specialized push call, got ${names}'

    assert names.any(it.contains('json2__LinkedList__last_T_') && it.contains('json2_ValueInfo')), 'expected specialized last call, got ${names}'

    assert 'LinkedList__push' !in names
    assert 'LinkedList__last' !in names
    assert 'json2__LinkedList__push' !in names
    assert 'json2__LinkedList__last' !in names
}

fn test_transform_nested_generic_receiver_method_call_in_monomorphized_clone() {
    files := transform_sources_for_test([
        TestSource{
            rel:  'x/json2/encode.v'
            code: '
module json2

pub struct EncoderOptions {}

pub struct Any {}

struct Encoder {}

pub fn encode[T](val T, config EncoderOptions) string {
    _ = config
    mut encoder := Encoder{}
    encoder.encode_value[T](val)
    return ""
}

fn (mut encoder Encoder) encode_value[T](val T) {
    _ = encoder
    _ = val
}
'
        },
        TestSource{
            rel:  'main.v'
            code: '
module main

import json2

fn use() {
    _ = json2.encode(json2.Any{}, json2.EncoderOptions{})
}
'
        },
    ])
    mut fn_names := []string{}
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl {
                fn_names << stmt.name
            }
        }
    }
    assert 'json2__encode_T_json2_Any' in fn_names
    assert 'encode_value_T_json2_Any' in fn_names
    call_names := call_names_for_fn(files, 'json2__encode_T_json2_Any')
    assert 'json2__Encoder__encode_value_T_json2_Any' in call_names
    assert 'encode_value_T_json2_Any' !in call_names
}

fn test_transform_eventbus_receiver_generic_method_call_is_monomorphized() {
    files := transform_sources_for_test([
        TestSource{
            rel:  'eventbus/eventbus.v'
            code: '
module eventbus

pub type EventHandlerFn = fn (receiver voidptr, args voidptr, sender voidptr)

pub struct Subscriber[T] {}

pub fn new_subscriber[T]() Subscriber[T] {
    return Subscriber[T]{}
}

pub fn (mut s Subscriber[T]) subscribe_method(name T, handler EventHandlerFn, receiver voidptr) {
    _ = s
    _ = name
    _ = handler
    _ = receiver
}
'
        },
        TestSource{
            rel:  'main.v'
            code: "
module main

import eventbus

fn handler(receiver voidptr, args voidptr, sender voidptr) {
    _ = receiver
    _ = args
    _ = sender
}

fn use() {
    mut subscriber := eventbus.new_subscriber[string]()
    subscriber.subscribe_method('ready', handler, unsafe { nil })
}
"
        },
    ])
    mut fn_names := []string{}
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl {
                fn_names << stmt.name
            }
        }
    }
    assert 'subscribe_method_T_string' in fn_names

    call_names := call_names_for_fn(files, 'use')
    assert 'eventbus__Subscriber__subscribe_method_T_string' in call_names
    assert 'eventbus__Subscriber__subscribe_method' !in call_names
}

fn test_transform_embedded_method_promotion_keeps_owner_method_precedence() {
    mut t := create_test_transformer()
    t.collect_declared_method_fns([
        ast.File{
            mod:   'main'
            stmts: [
                ast.Stmt(ast.FnDecl{
                    name:      'redirect_to_index'
                    is_method: true
                    receiver:  ast.Parameter{
                        name: 'ctx'
                        typ:  ast.Expr(ast.Ident{
                            name: 'Context'
                        })
                    }
                }),
            ]
        },
    ])
    recv_type := types.Type(types.Struct{
        name: 'Context'
    })
    resolved := t.resolve_cached_method_fn_name_for_type(recv_type, 'redirect_to_index', 'Context') or {
        panic('missing declared owner method')
    }
    assert resolved == 'Context__redirect_to_index'
    assert 'Context__redirect_to_index' in t.declared_method_fns
}

fn test_generic_receiver_bindings_prefer_declared_selector_over_stale_wrapper_type() {
    value_info_type := types.Type(types.Struct{
        name: 'json2__ValueInfo'
    })
    template_type := types.Type(types.Struct{
        name:           'json2__LinkedList'
        generic_params: ['T']
        fields:         [
            types.Field{
                name: 'item'
                typ:  types.Type(types.NamedType('T'))
            },
        ]
    })
    concrete_type := types.Type(types.Struct{
        name:   'json2__LinkedList'
        fields: [
            types.Field{
                name: 'item'
                typ:  value_info_type
            },
        ]
    })
    decoder_type := types.Type(types.Struct{
        name:   'json2__Decoder'
        fields: [
            types.Field{
                name: 'values_info'
                typ:  concrete_type
            },
        ]
    })
    mut env := types.Environment.new()
    env.set_expr_type(701, template_type)
    mut scope := types.new_scope(unsafe { nil })
    scope.insert('checker', value_object_from_type(decoder_type))
    scope.insert_type('LinkedList', template_type)
    scope.insert_type('json2__LinkedList', template_type)
    mut t := Transformer{
        pref:             &vpref.Preferences{}
        env:              unsafe { env }
        scope:            scope
        cur_module:       'json2'
        cached_scopes:    {
            'json2': scope
        }
        local_decl_types: map[string]types.Type{}
    }
    receiver := ast.Expr(ast.ParenExpr{
        expr: ast.Expr(ast.SelectorExpr{
            lhs: ast.Ident{
                name: 'checker'
            }
            rhs: ast.Ident{
                name: 'values_info'
            }
        })
        pos:  token.Pos{
            id: 701
        }
    })
    decl := ast.FnDecl{
        name:      'last'
        is_method: true
        receiver:  ast.Parameter{
            name: 'list'
            typ:  ast.Expr(ast.PrefixExpr{
                op:   .amp
                expr: ast.Expr(ast.GenericArgOrIndexExpr{
                    lhs:  ast.Expr(ast.Ident{
                        name: 'LinkedList'
                    })
                    expr: ast.Expr(ast.Ident{
                        name: 'T'
                    })
                })
            })
        }
    }
    bindings := t.generic_bindings_from_method_receiver(decl, receiver, 'json2__LinkedList__last') or {
        panic('missing receiver bindings')
    }
    binding := bindings['T'] or { panic('missing T binding') }
    assert binding is types.Struct
    assert (binding as types.Struct).name == 'json2__ValueInfo'
}

fn test_decl_assign_rune_arithmetic_keeps_rune_storage_type() {
    mut t := create_transformer_with_vars({
        'unicode_point':  types.builtin_type('rune') or { rune_type() }
        'unicode_point2': types.builtin_type('rune') or { rune_type() }
    })
    mut env := types.Environment.new()
    env.set_expr_type(93, types.Type(types.int_))
    env.set_expr_type(94, types.Type(types.int_))
    env.set_expr_type(95, types.Type(types.int_))
    t.env = unsafe { env }
    lhs := ast.Expr(ast.Ident{
        name: 'final_unicode_point'
        pos:  token.Pos{
            id: 93
        }
    })
    cast_rhs := ast.Expr(ast.CastExpr{
        typ:  ast.Expr(ast.Ident{
            name: 'rune'
        })
        expr: ast.Expr(ast.BasicLiteral{
            kind:  .number
            value: '0'
        })
    })
    cast_typ := t.decl_assign_storage_type(lhs, cast_rhs) or { panic('missing cast type') }
    assert cast_typ is types.Rune
    rhs := ast.Expr(ast.InfixExpr{
        op:  .plus
        lhs: ast.Expr(ast.InfixExpr{
            op:  .amp
            lhs: ast.Expr(ast.Ident{
                name: 'unicode_point2'
                pos:  token.Pos{
                    id: 94
                }
            })
            rhs: ast.Expr(ast.BasicLiteral{
                kind:  .number
                value: '0x3FF'
            })
        })
        rhs: ast.Expr(ast.InfixExpr{
            op:  .left_shift
            lhs: ast.Expr(ast.InfixExpr{
                op:  .amp
                lhs: ast.Expr(ast.Ident{
                    name: 'unicode_point'
                    pos:  token.Pos{
                        id: 95
                    }
                })
                rhs: ast.Expr(ast.BasicLiteral{
                    kind:  .number
                    value: '0x3FF'
                })
            })
            rhs: ast.Expr(ast.BasicLiteral{
                kind:  .number
                value: '10'
            })
        })
    })
    typ := t.decl_assign_storage_type(lhs, rhs) or { panic('missing rune arithmetic type') }
    assert typ is types.Rune
}

fn test_runtime_const_init_main_calls_run_main_consts_after_module_inits() {
    mut t := create_test_transformer()
    t.runtime_const_modules << 'main'
    t.runtime_const_init_fn_name['main'] = '__v_init_consts_main'
    files := [
        ast.File{
            mod:   'main'
            stmts: [
                ast.Stmt(ast.FnDecl{
                    name: 'main'
                }),
            ]
        },
        ast.File{
            mod:   'rand'
            stmts: [
                ast.Stmt(ast.FnDecl{
                    name: 'init'
                }),
            ]
        },
    ]
    calls := t.runtime_const_init_main_calls_parts(files)
    mut names := []string{}
    for call_stmt in calls {
        collect_call_names_from_stmt(call_stmt, mut names)
    }
    assert names == ['rand__init', '__v_init_consts_main']
}

fn stmt_has_assign_op(stmt ast.Stmt, op token.Token) bool {
    match stmt {
        ast.AssignStmt {
            return stmt.op == op
        }
        ast.BlockStmt {
            for nested in stmt.stmts {
                if stmt_has_assign_op(nested, op) {
                    return true
                }
            }
        }
        ast.ExprStmt {
            return expr_has_assign_op(stmt.expr, op)
        }
        ast.ForStmt {
            if stmt_has_assign_op(stmt.init, op) || stmt_has_assign_op(stmt.post, op) {
                return true
            }
            for nested in stmt.stmts {
                if stmt_has_assign_op(nested, op) {
                    return true
                }
            }
        }
        ast.LabelStmt {
            return stmt_has_assign_op(stmt.stmt, op)
        }
        else {}
    }

    return false
}

fn expr_has_assign_op(expr ast.Expr, op token.Token) bool {
    match expr {
        ast.IfExpr {
            for stmt in expr.stmts {
                if stmt_has_assign_op(stmt, op) {
                    return true
                }
            }
            return expr_has_assign_op(expr.else_expr, op)
        }
        ast.MatchExpr {
            for branch in expr.branches {
                for stmt in branch.stmts {
                    if stmt_has_assign_op(stmt, op) {
                        return true
                    }
                }
            }
        }
        ast.UnsafeExpr {
            for stmt in expr.stmts {
                if stmt_has_assign_op(stmt, op) {
                    return true
                }
            }
        }
        else {}
    }

    return false
}

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

fn count_label_name_in_files(files []ast.File, fn_name string, label string) int {
    mut count := 0
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.name == fn_name {
                count += count_label_name_in_stmts(stmt.stmts, label)
            }
        }
    }
    return count
}

fn count_label_name_in_stmts(stmts []ast.Stmt, label string) int {
    mut count := 0
    for stmt in stmts {
        count += count_label_name_in_stmt(stmt, label)
    }
    return count
}

fn count_label_name_in_stmt(stmt ast.Stmt, label string) int {
    match stmt {
        ast.BlockStmt {
            return count_label_name_in_stmts(stmt.stmts, label)
        }
        ast.ComptimeStmt {
            return count_label_name_in_stmt(stmt.stmt, label)
        }
        ast.DeferStmt {
            return count_label_name_in_stmts(stmt.stmts, label)
        }
        ast.ExprStmt {
            return count_label_name_in_expr(stmt.expr, label)
        }
        ast.ForStmt {
            return count_label_name_in_stmt(stmt.init, label) +
                count_label_name_in_stmt(stmt.post, label) +
                count_label_name_in_expr(stmt.cond, label) +
                count_label_name_in_stmts(stmt.stmts, label)
        }
        ast.LabelStmt {
            mut count := if stmt.name == label { 1 } else { 0 }
            count += count_label_name_in_stmt(stmt.stmt, label)
            return count
        }
        ast.ReturnStmt {
            mut count := 0
            for expr in stmt.exprs {
                count += count_label_name_in_expr(expr, label)
            }
            return count
        }
        else {
            return 0
        }
    }
}

fn count_label_name_in_expr(expr ast.Expr, label string) int {
    match expr {
        ast.IfExpr {
            return count_label_name_in_expr(expr.cond, label) +
                count_label_name_in_stmts(expr.stmts, label) +
                count_label_name_in_expr(expr.else_expr, label)
        }
        ast.MatchExpr {
            mut count := 0
            for branch in expr.branches {
                count += count_label_name_in_stmts(branch.stmts, label)
            }
            return count
        }
        ast.UnsafeExpr {
            return count_label_name_in_stmts(expr.stmts, label)
        }
        else {
            return 0
        }
    }
}

fn find_call_with_lhs_suffix_in_stmts(stmts []ast.Stmt, suffix string) ?ast.CallExpr {
    for stmt in stmts {
        if call := find_call_with_lhs_suffix_in_stmt(stmt, suffix) {
            return call
        }
    }
    return none
}

fn find_call_with_lhs_suffix_in_stmt(stmt ast.Stmt, suffix string) ?ast.CallExpr {
    match stmt {
        ast.AssignStmt {
            for expr in stmt.lhs {
                if call := find_call_with_lhs_suffix_in_expr(expr, suffix) {
                    return call
                }
            }
            for expr in stmt.rhs {
                if call := find_call_with_lhs_suffix_in_expr(expr, suffix) {
                    return call
                }
            }
        }
        ast.BlockStmt {
            return find_call_with_lhs_suffix_in_stmts(stmt.stmts, suffix)
        }
        ast.ExprStmt {
            return find_call_with_lhs_suffix_in_expr(stmt.expr, suffix)
        }
        ast.ForInStmt {
            if call := find_call_with_lhs_suffix_in_expr(stmt.expr, suffix) {
                return call
            }
        }
        ast.ForStmt {
            if call := find_call_with_lhs_suffix_in_stmt(stmt.init, suffix) {
                return call
            }
            if call := find_call_with_lhs_suffix_in_expr(stmt.cond, suffix) {
                return call
            }
            if call := find_call_with_lhs_suffix_in_stmt(stmt.post, suffix) {
                return call
            }
            return find_call_with_lhs_suffix_in_stmts(stmt.stmts, suffix)
        }
        ast.FnDecl {
            return find_call_with_lhs_suffix_in_stmts(stmt.stmts, suffix)
        }
        ast.ReturnStmt {
            for expr in stmt.exprs {
                if call := find_call_with_lhs_suffix_in_expr(expr, suffix) {
                    return call
                }
            }
        }
        else {}
    }

    return none
}

fn find_call_with_lhs_suffix_in_expr(expr ast.Expr, suffix string) ?ast.CallExpr {
    match expr {
        ast.ArrayInitExpr {
            for item in expr.exprs {
                if call := find_call_with_lhs_suffix_in_expr(item, suffix) {
                    return call
                }
            }
        }
        ast.CallExpr {
            if expr.lhs is ast.Ident && (expr.lhs as ast.Ident).name.ends_with(suffix) {
                return expr
            }
            if call := find_call_with_lhs_suffix_in_expr(expr.lhs, suffix) {
                return call
            }
            for arg in expr.args {
                if call := find_call_with_lhs_suffix_in_expr(arg, suffix) {
                    return call
                }
            }
        }
        ast.CastExpr {
            return find_call_with_lhs_suffix_in_expr(expr.expr, suffix)
        }
        ast.FieldInit {
            return find_call_with_lhs_suffix_in_expr(expr.value, suffix)
        }
        ast.IfExpr {
            if call := find_call_with_lhs_suffix_in_expr(expr.cond, suffix) {
                return call
            }
            if call := find_call_with_lhs_suffix_in_stmts(expr.stmts, suffix) {
                return call
            }
            return find_call_with_lhs_suffix_in_expr(expr.else_expr, suffix)
        }
        ast.InfixExpr {
            if call := find_call_with_lhs_suffix_in_expr(expr.lhs, suffix) {
                return call
            }
            return find_call_with_lhs_suffix_in_expr(expr.rhs, suffix)
        }
        ast.InitExpr {
            for field in expr.fields {
                if call := find_call_with_lhs_suffix_in_expr(field.value, suffix) {
                    return call
                }
            }
        }
        ast.MatchExpr {
            if call := find_call_with_lhs_suffix_in_expr(expr.expr, suffix) {
                return call
            }
            for branch in expr.branches {
                if call := find_call_with_lhs_suffix_in_stmts(branch.stmts, suffix) {
                    return call
                }
            }
        }
        ast.ModifierExpr {
            return find_call_with_lhs_suffix_in_expr(expr.expr, suffix)
        }
        ast.ParenExpr {
            return find_call_with_lhs_suffix_in_expr(expr.expr, suffix)
        }
        ast.PostfixExpr {
            return find_call_with_lhs_suffix_in_expr(expr.expr, suffix)
        }
        ast.PrefixExpr {
            return find_call_with_lhs_suffix_in_expr(expr.expr, suffix)
        }
        ast.SelectorExpr {
            return find_call_with_lhs_suffix_in_expr(expr.lhs, suffix)
        }
        ast.UnsafeExpr {
            return find_call_with_lhs_suffix_in_stmts(expr.stmts, suffix)
        }
        else {}
    }

    return none
}

// string_type returns the builtin v2 string type.
fn string_type() types.Type {
    return types.string_
}

fn test_transform_decl_assign_keeps_explicit_as_cast_type_with_stale_lhs_name_scope() {
    env := &types.Environment{}
    mut scope := types.new_scope(unsafe { nil })
    scope.insert('inner', types.Type(types.Struct{
        name: 'ast__Expr'
    }))
    mut t := &Transformer{
        pref:                        &vpref.Preferences{}
        env:                         unsafe { env }
        scope:                       scope
        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{}
    }
    result := t.transform_assign_stmt(ast.AssignStmt{
        op:  .decl_assign
        lhs: [
            ast.Expr(ast.Ident{
                name: 'inner'
            }),
        ]
        rhs: [
            ast.Expr(ast.AsCastExpr{
                expr: ast.Expr(ast.Ident{
                    name: 'node'
                })
                typ:  ast.Expr(ast.SelectorExpr{
                    lhs: ast.Expr(ast.Ident{
                        name: 'ast'
                    })
                    rhs: ast.Ident{
                        name: 'PrefixExpr'
                    }
                })
            }),
        ]
    })
    assert result.rhs[0] is ast.AsCastExpr
}

fn test_transform_decl_assign_does_not_wrap_rhs_with_stale_lhs_sumtype_scope() {
    env := &types.Environment{}
    type_sum := types.Type(types.SumType{
        name:     'types__Type'
        variants: [string_type()]
    })
    mut scope := types.new_scope(unsafe { nil })
    scope.insert('receiver_type', type_sum)
    mut types_scope := types.new_scope(unsafe { nil })
    types_scope.insert('Type', type_sum)
    mut t := &Transformer{
        pref:                        &vpref.Preferences{}
        env:                         unsafe { env }
        scope:                       scope
        cur_module:                  'transformer'
        cached_scopes:               {
            'types': types_scope
        }
        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{}
    }
    result := t.transform_assign_stmt(ast.AssignStmt{
        op:  .decl_assign
        lhs: [
            ast.Expr(ast.Ident{
                name: 'receiver_type'
            }),
        ]
        rhs: [
            ast.Expr(ast.StringLiteral{
                value: 'flag'
                kind:  .v
            }),
        ]
    })
    assert result.rhs[0] is ast.StringLiteral
}

fn test_transform_decl_assign_registers_smartcast_selector_type() {
    env := &types.Environment{}
    mut ast_scope := types.new_scope(unsafe { nil })
    ast_scope.insert('Interface', types.Type(types.Struct{
        name: 'ast__Interface'
    }))
    mut fn_scope := types.new_scope(unsafe { nil })
    mut t := &Transformer{
        pref:                        &vpref.Preferences{}
        env:                         unsafe { env }
        scope:                       fn_scope
        fn_root_scope:               fn_scope
        cur_module:                  'checker'
        cached_scopes:               {
            'ast': ast_scope
        }
        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{}
    }
    t.push_smartcast_full('parent_sym.info', 'ast__Interface', 'ast__Interface', 'ast__TypeInfo')
    _ := t.transform_assign_stmt(ast.AssignStmt{
        op:  .decl_assign
        lhs: [ast.Expr(ast.Ident{
            name: 'generic_info'
        })]
        rhs: [
            ast.Expr(ast.SelectorExpr{
                lhs: ast.Expr(ast.Ident{
                    name: 'parent_sym'
                })
                rhs: ast.Ident{
                    name: 'info'
                }
            }),
        ]
    })
    typ := fn_scope.lookup_var_type('generic_info') or {
        assert false, 'generic_info type was not registered'
        return
    }
    assert typ is types.Struct
    assert (typ as types.Struct).name == 'ast__Interface'
}

fn test_smartcast_method_call_prefers_variant_method_over_sumtype_method() {
    files := transform_code_for_test('
struct Primitive {}

struct Enum {
    name string
}

type Type = Primitive | Enum

fn (t Type) name() string {
    _ = t
    return "type"
}

fn (t Primitive) name() string {
    _ = t
    return "primitive"
}

fn (t Enum) name() string {
    return t.name
}

fn type_name(t Type) string {
    return match t {
        Primitive, Enum { t.name() }
    }
}
')
    call_names := call_names_for_fn(files, 'type_name')
    assert 'Primitive__name' in call_names
    assert 'Enum__name' in call_names
    assert 'Type__name' !in call_names
}

fn test_flag_enum_set_on_local_variable_lowers_to_assignment() {
    files := transform_code_for_test('
@[flag]
enum Flags {
    empty
    enabled
}

fn set_flag() Flags {
    mut attrs := Flags.empty
    attrs.set(.enabled)
    return attrs
}
')
    call_names := call_names_for_fn(files, 'set_flag')
    assert 'Flags__set' !in call_names
    assert fn_has_assign_op(files, 'set_flag', .or_assign)
}

fn test_flag_enum_set_inside_statement_match_lowers_to_assignment() {
    files := transform_code_for_test('
@[flag]
enum Flags {
    empty
    enabled
}

fn set_flag(names []string) Flags {
    mut attrs := Flags.empty
    for name in names {
        match name {
            "enabled" { attrs.set(.enabled) }
            else {}
        }
    }
    return attrs
}
')
    call_names := call_names_for_fn(files, 'set_flag')
    assert 'Flags__set' !in call_names
    assert fn_has_assign_op(files, 'set_flag', .or_assign)
}

fn test_embedded_struct_selector_uses_embedded_method_owner() {
    files := transform_code_for_test('
struct Request {}
struct Response {}

struct SilentStreamingDownloader {}

fn (mut d SilentStreamingDownloader) on_finish(request &Request, response &Response) ! {
    _ = request
    _ = response
}

struct TerminalStreamingDownloader {
    SilentStreamingDownloader
}

fn finish(mut d TerminalStreamingDownloader, request &Request, response &Response) ! {
    d.SilentStreamingDownloader.on_finish(request, response)!
}
')
    call_names := call_names_for_fn(files, 'finish')
    assert 'SilentStreamingDownloader__on_finish' in call_names
    assert 'int__on_finish' !in call_names
}

fn test_promoted_embedded_generic_method_call_lowers_to_concrete_method() {
    files := transform_code_for_test('
struct Options[T] {
    handler fn (mut ctx T) bool
}

struct Middleware[T] {}

fn (mut m Middleware[T]) use(options Options[T]) {
    _ = options
}

struct Context {}

struct App {
    Middleware[Context]
}

fn (mut app App) before_request(mut ctx Context) bool {
    _ = ctx
    return true
}

fn main() {
    mut app := App{}
    app.use(handler: app.before_request)
}
')
    mut fn_names := []string{}
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl {
                fn_names << stmt.name
            }
        }
    }
    call_names := call_names_for_fn(files, 'main')
    assert 'use_T_Context' in fn_names
    assert 'Middleware__use_T_Context' in call_names
    assert 'app.use' !in call_names
}

fn test_promoted_embedded_generic_method_uses_live_struct_metadata() {
    files := transform_code_for_test('
struct Result {}

struct BaseContext {}

fn (mut ctx BaseContext) json[T](j T) Result {
    _ = j
    return Result{}
}

struct Context {
    BaseContext
}

struct App {}

fn (mut app App) index(mut ctx Context) Result {
    _ = app
    return ctx.json("ok")
}

fn main() {
    mut app := App{}
    mut ctx := Context{}
    _ = app.index(mut ctx)
}
')
    call_names := call_names_for_fn(files, 'index')
    assert 'BaseContext__json_T_string' in call_names
    assert 'ctx.json' !in call_names
}

fn test_alias_receiver_method_is_resolved_before_base_container_method() {
    files := transform_code_for_test('
type Builder = []u8

fn (mut b Builder) str() string {
    _ = b
    return ""
}

fn builder_str() string {
    mut b := Builder([]u8{})
    return b.str()
}
')
    call_names := call_names_for_fn(files, 'builder_str')
    assert 'Builder__str' in call_names
    assert 'array__str' !in call_names
}

fn test_string_interpolation_does_not_generate_default_over_explicit_str_method() {
    files := transform_code_for_test('
module globset

pub struct ErrorKind {}

pub fn (kind ErrorKind) str() string {
    _ = kind
    return "custom"
}

pub fn message(kind ErrorKind) string {
    return "\${kind}"
}
')
    mut explicit_methods := 0
    mut generated_defaults := 0
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl {
                if stmt.is_method && stmt.name == 'str' {
                    explicit_methods++
                }
                if !stmt.is_method && stmt.name == 'globset__ErrorKind__str' {
                    generated_defaults++
                }
            }
        }
    }
    call_names := call_names_for_fn(files, 'message')
    assert explicit_methods == 1
    assert generated_defaults == 0
    assert 'globset__ErrorKind__str' in call_names
}

fn test_array_str_call_uses_element_specific_helper() {
    files := transform_code_for_test('
module globset

pub struct Token {}

pub fn (tok Token) str() string {
    _ = tok
    return "Token"
}

pub fn show(tokens []Token) string {
    return tokens.str()
}
')
    call_names := call_names_for_fn(files, 'show')
    assert 'Array_globset__Token_str' in call_names
    assert 'array__str' !in call_names
}

fn test_string_array_str_call_keeps_builtin_method() {
    files := transform_code_for_test('
module builtin

fn (a []string) str() string {
    _ = a
    return ""
}

fn show(values []string) string {
    return values.str()
}
')
    call_names := call_names_for_fn(files, 'show')
    assert 'Array_string__str' in call_names
    assert 'Array_string_str' !in call_names
}

fn test_qualified_alias_receiver_uses_concrete_base_method_with_same_short_name() {
    files := transform_sources_for_test([
        TestSource{
            rel:  'base/base.v'
            code: 'module base

pub struct SSLConn {}

pub fn (mut s SSLConn) connect() {
    _ = s
}
'
        },
        TestSource{
            rel:  'ssl/ssl.v'
            code: 'module ssl

import base

pub type SSLConn = base.SSLConn
'
        },
        TestSource{
            rel:  'main.v'
            code: 'module main

import ssl

fn call(mut s ssl.SSLConn) {
    s.connect()
}
'
        },
    ])
    call_names := call_names_for_fn(files, 'call')
    assert 'base__SSLConn__connect' in call_names, 'expected base method owner, got ${call_names}'
    assert 'ssl__SSLConn__connect' !in call_names
}

fn test_imported_global_receiver_method_uses_global_type() {
    files := transform_sources_for_test([
        TestSource{
            rel:  'ast/ast.v'
            code: 'module ast

pub type Type = u32

pub struct Table {}

pub __global global_table = &Table(unsafe { nil })

pub fn (t &Table) type_to_str(typ Type) string {
    _ = t
    _ = typ
    return ""
}
'
        },
        TestSource{
            rel:  'main.v'
            code: 'module transformer

import ast

struct Param {
    typ ast.Type
}

struct FnDecl {
    receiver Param
}

fn call(node &FnDecl) string {
    return ast.global_table.type_to_str(node.receiver.typ)
}
'
        },
    ])
    call_names := call_names_for_fn(files, 'call')
    assert 'ast__Table__type_to_str' in call_names, 'expected ast.Table method owner, got ${call_names}'
    assert 'int__type_to_str' !in call_names
}

fn test_sumtype_type_name_on_imported_struct_field_is_lowered() {
    files := transform_sources_for_test([
        TestSource{
            rel:  'astx/astx.v'
            code: 'module astx

pub type Expr = Ident | Number

pub struct Ident {}

pub struct Number {}

pub struct CallExpr {
pub:
    lhs Expr
}
'
        },
        TestSource{
            rel:  'main.v'
            code: 'module main

import astx

fn call_target_kind(expr astx.CallExpr) string {
    return expr.lhs.type_name()
}
'
        },
    ])
    call_names := call_names_for_fn(files, 'call_target_kind')
    assert 'astx__Expr__type_name' !in call_names
    assert 'Expr__type_name' !in call_names
}

fn test_map_alias_field_clone_lowers_to_builtin_map_clone() {
    files := transform_code_for_test('
type TypeID = int

struct TypeStore {
    cache map[string]TypeID
}

struct Module {
    type_store TypeStore
}

fn clone_cache(m Module) map[string]TypeID {
    return m.type_store.cache.clone()
}
')
    call_names := call_names_for_fn(files, 'clone_cache')
    assert 'map__clone' in call_names
    assert 'Map_string_TypeID__clone' !in call_names
    assert 'Map_string_main__TypeID__clone' !in call_names
}

fn test_string_index_byte_methods_on_nested_receiver_fields_use_u8_receiver() {
    files := transform_code_for_test('
struct Scanner {
    src string
    offset int
}

struct Parser {
    scanner &Scanner
}

fn (c u8) is_space() bool {
    return true
}

fn (c u8) is_letter() bool {
    return true
}

fn (p &Parser) peek_dollar_keyword() string {
    if p.scanner.offset >= p.scanner.src.len {
        return ""
    }
    mut idx := p.scanner.offset
    for idx < p.scanner.src.len && p.scanner.src[idx].is_space() {
        idx++
    }
    start := idx
    for idx < p.scanner.src.len && p.scanner.src[idx].is_letter() {
        idx++
    }
    return p.scanner.src[start..idx]
}
')
    call_names := call_names_for_fn(files, 'peek_dollar_keyword')
    assert 'u8__is_space' in call_names
    assert 'u8__is_letter' in call_names
    assert 'int__is_space' !in call_names
    assert 'int__is_letter' !in call_names
}

fn test_smartcast_call_arg_keeps_original_sumtype_when_param_expects_sumtype() {
    files := transform_code_for_test('
struct Table {}

struct Checker {
    table Table
}

struct GlobalField {}
struct Var {}

type ScopeObject = GlobalField | Var

fn (t Table) is_interface_var(obj ScopeObject) bool {
    _ = t
    _ = obj
    return true
}

fn uses_scope_object(mut c Checker, mut obj ScopeObject) bool {
    match mut obj {
        Var {
            return c.table.is_interface_var(obj)
        }
        else {}
    }
    return false
}
')
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.name == 'uses_scope_object' {
                call := find_call_with_lhs_suffix_in_stmts(stmt.stmts, '__is_interface_var') or {
                    assert false, 'expected transformed is_interface_var call'
                    return
                }
                assert call.args.len > 0
                arg := call.args[call.args.len - 1]
                assert arg is ast.Ident, 'sumtype call arg was wrapped as ${arg.type_name()}'
                assert (arg as ast.Ident).name == 'obj'
                return
            }
        }
    }
    assert false, 'uses_scope_object was not found'
}

fn test_smartcast_method_call_arg_keeps_original_sumtype_when_param_expects_sumtype() {
    files := transform_code_for_test('
struct Holder {}
struct Gen {}

type Type = Holder | int

fn (mut g Gen) use_type(value Type, holder Holder) {
    _ = g
    _ = value
    _ = holder
}

fn use_smartcasted_type(mut g Gen, concrete Type) {
    if concrete is Holder {
        g.use_type(concrete, concrete as Holder)
    }
}
')
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.name == 'use_smartcasted_type' {
                call := find_call_with_lhs_suffix_in_stmts(stmt.stmts, 'Gen__use_type') or {
                    assert false, 'expected transformed Gen__use_type call'
                    return
                }
                assert call.args.len == 3
                arg := call.args[1]
                assert arg is ast.Ident, 'sumtype method call arg was wrapped as ${arg.type_name()}'
                assert (arg as ast.Ident).name == 'concrete'
                return
            }
        }
    }
    assert false, 'use_smartcasted_type was not found'
}

fn test_map_index_or_decl_keeps_declared_sumtype_for_later_smartcast_call_arg() {
    files := transform_code_for_test('
struct Holder {}
struct Gen {}

type Type = Holder | int

fn (mut g Gen) use_type(value Type, holder Holder) {
    _ = g
    _ = value
    _ = holder
}

fn use_map_or_smartcasted_type(mut g Gen, active map[string]Type, name string) {
    concrete := active[name] or { return }
    if concrete !is Holder {
        return
    }
    g.use_type(concrete, concrete as Holder)
}
')
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.name == 'use_map_or_smartcasted_type' {
                call := find_call_with_lhs_suffix_in_stmts(stmt.stmts, 'Gen__use_type') or {
                    assert false, 'expected transformed Gen__use_type call'
                    return
                }
                assert call.args.len == 3
                arg := call.args[1]
                assert arg is ast.Ident, 'sumtype method call arg was wrapped as ${arg.type_name()}'
                assert (arg as ast.Ident).name == 'concrete'
                return
            }
        }
    }
    assert false, 'use_map_or_smartcasted_type was not found'
}

fn test_sumtype_call_arg_uses_declared_local_type_when_current_type_is_narrowed() {
    global_field_type := types.Type(types.Struct{
        name: 'GlobalField'
    })
    var_type := types.Type(types.Struct{
        name: 'Var'
    })
    scope_object_type := types.Type(types.SumType{
        name:     'ScopeObject'
        variants: [global_field_type, var_type]
    })
    mut scope := types.new_scope(unsafe { nil })
    scope.insert('GlobalField', global_field_type)
    scope.insert('Var', var_type)
    scope.insert('ScopeObject', scope_object_type)
    scope.insert_or_update('obj', var_type)
    mut env := types.Environment.new()
    obj_pos := token.Pos{
        id: 8901
    }
    env.set_expr_type(obj_pos.id, var_type)
    mut t := &Transformer{
        pref:                        &vpref.Preferences{}
        env:                         unsafe { env }
        scope:                       scope
        fn_root_scope:               scope
        cached_scopes:               {
            'main': scope
        }
        local_decl_types:            {
            'obj': scope_object_type
        }
        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{}
        smartcast_expr_counts:       map[string]int{}
    }
    arg := ast.Expr(ast.Ident{
        name: 'obj'
        pos:  obj_pos
    })
    out := t.transform_call_arg_with_sumtype_check(arg, CallFnInfo{
        param_types: [scope_object_type]
    }, 0)
    assert out is ast.Ident, 'declared sumtype local was wrapped as ${out.type_name()}'
    assert (out as ast.Ident).name == 'obj'
}

fn test_is_pointer_type_handles_unresolved_alias_base_type() {
    t := create_test_transformer()
    assert !t.is_pointer_type(types.Type(types.Alias{
        name: 'UnresolvedAlias'
    }))
}

fn test_expr_to_string_handles_no_arg_selector_call_for_smartcasts() {
    t := create_test_transformer()
    call := ast.Expr(ast.CallExpr{
        lhs: ast.Expr(ast.SelectorExpr{
            lhs: ast.Expr(ast.SelectorExpr{
                lhs: ast.Expr(ast.Ident{
                    name: 'branch'
                })
                rhs: ast.Ident{
                    name: 'stmts'
                }
            })
            rhs: ast.Ident{
                name: 'last'
            }
        })
    })
    assert t.expr_to_string(call) == 'branch.stmts.last()'
}

fn test_expr_to_string_handles_indexed_selector_for_smartcasts() {
    t := create_test_transformer()
    expr := ast.Expr(ast.SelectorExpr{
        lhs: ast.Expr(ast.IndexExpr{
            lhs:  ast.Expr(ast.SelectorExpr{
                lhs: ast.Expr(ast.Ident{
                    name: 'node'
                })
                rhs: ast.Ident{
                    name: 'branches'
                }
            })
            expr: ast.Expr(ast.BasicLiteral{
                kind:  .number
                value: '0'
            })
        })
        rhs: ast.Ident{
            name: 'cond'
        }
    })
    assert t.expr_to_string(expr) == 'node.branches[0].cond'
}

fn test_smartcast_context_from_lowered_tag_check_uses_sumtype_metadata() {
    variants := [
        types.Type(types.Struct{
            name: 'ast__Ident'
        }),
        types.Type(types.Struct{
            name: 'ast__BasicLiteral'
        }),
    ]
    sum_type := types.Type(types.SumType{
        name:     'ast__Expr'
        variants: variants
    })
    mut ast_scope := types.new_scope(unsafe { nil })
    ast_scope.insert('Expr', sum_type)
    ast_scope.insert('Ident', variants[0])
    mut fn_scope := types.new_scope(unsafe { nil })
    fn_scope.insert('node', sum_type)
    env := &types.Environment{}
    t := &Transformer{
        pref:                        &vpref.Preferences{}
        env:                         unsafe { env }
        scope:                       fn_scope
        cur_module:                  'checker'
        cached_scopes:               {
            'ast': ast_scope
        }
        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{}
    }
    ctx := t.smartcast_context_from_condition_term(ast.InfixExpr{
        op:  .eq
        lhs: ast.Expr(ast.SelectorExpr{
            lhs: ast.Expr(ast.Ident{
                name: 'node'
            })
            rhs: ast.Ident{
                name: '_tag'
            }
        })
        rhs: ast.Expr(ast.BasicLiteral{
            kind:  .number
            value: '0'
        })
    }) or {
        assert false, 'lowered tag check did not recover smartcast context'
        return
    }
    assert ctx.expr == 'node'
    assert ctx.variant == 'ast__Ident'
    assert ctx.variant_full == 'ast__Ident'
    assert ctx.sumtype == 'ast__Expr'
}

fn test_if_mut_selector_smartcast_rewrites_body_selector() {
    expr_sum_type := types.Type(types.SumType{
        name:     'ast__Expr'
        variants: [
            types.Type(types.Struct{
                name:   'ast__Ident'
                fields: [
                    types.Field{
                        name: 'language'
                        typ:  types.Type(types.Enum{
                            name: 'ast__Language'
                        })
                    },
                ]
            }),
            types.Type(types.Struct{
                name: 'ast__BasicLiteral'
            }),
        ]
    })
    mut ast_scope := types.new_scope(unsafe { nil })
    ast_scope.insert('Expr', expr_sum_type)
    ast_scope.insert('Ident', types.Type(types.Struct{
        name:   'ast__Ident'
        fields: [
            types.Field{
                name: 'language'
                typ:  types.Type(types.Enum{
                    name: 'ast__Language'
                })
            },
        ]
    }))
    ast_scope.insert('EnumField', types.Type(types.Struct{
        name:   'ast__EnumField'
        fields: [
            types.Field{
                name: 'expr'
                typ:  expr_sum_type
            },
        ]
    }))
    mut fn_scope := types.new_scope(unsafe { nil })
    fn_scope.insert('field', types.Type(types.Pointer{
        base_type: types.Type(types.Struct{
            name: 'ast__EnumField'
        })
    }))
    env := &types.Environment{}
    mut t := &Transformer{
        pref:                        &vpref.Preferences{}
        env:                         unsafe { env }
        scope:                       fn_scope
        cur_module:                  'checker'
        cached_scopes:               {
            'ast': ast_scope
        }
        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{}
        synth_types:                 map[int]types.Type{}
        smartcast_expr_counts:       map[string]int{}
    }
    field_expr := ast.Expr(ast.SelectorExpr{
        lhs: ast.Expr(ast.Ident{
            name: 'field'
        })
        rhs: ast.Ident{
            name: 'expr'
        }
    })
    result := t.transform_expr(ast.Expr(ast.IfExpr{
        cond:  ast.Expr(ast.InfixExpr{
            op:  .key_is
            lhs: ast.Expr(ast.ModifierExpr{
                kind: .key_mut
                expr: field_expr
            })
            rhs: ast.Expr(ast.SelectorExpr{
                lhs: ast.Expr(ast.Ident{
                    name: 'ast'
                })
                rhs: ast.Ident{
                    name: 'Ident'
                }
            })
        })
        stmts: [
            ast.Stmt(ast.ExprStmt{
                expr: ast.Expr(ast.SelectorExpr{
                    lhs: field_expr
                    rhs: ast.Ident{
                        name: 'language'
                    }
                })
            }),
        ]
    }))
    assert result is ast.IfExpr
    if_expr := result as ast.IfExpr
    assert if_expr.stmts.len == 1
    assert if_expr.stmts[0] is ast.ExprStmt
    stmt := if_expr.stmts[0] as ast.ExprStmt
    assert stmt.expr is ast.SelectorExpr
    selector := stmt.expr as ast.SelectorExpr
    assert selector.lhs is ast.CastExpr, 'selector lhs was not narrowed: ${selector.lhs.type_name()}'
    cast := selector.lhs as ast.CastExpr
    assert cast.typ.name() == 'ast__Ident*'
}

fn test_for_mut_selector_smartcast_rewrites_assignment_rhs_selector() {
    type_info_type := types.Type(types.SumType{
        name:     'ast__TypeInfo'
        variants: [
            types.Type(types.Struct{
                name:   'ast__Array'
                fields: [
                    types.Field{
                        name: 'elem_type'
                        typ:  types.Type(types.Struct{
                            name: 'ast__Type'
                        })
                    },
                ]
            }),
            types.Type(types.Struct{
                name: 'ast__Struct'
            }),
        ]
    })
    mut ast_scope := types.new_scope(unsafe { nil })
    ast_scope.insert('TypeInfo', type_info_type)
    ast_scope.insert('Array', types.Type(types.Struct{
        name:   'ast__Array'
        fields: [
            types.Field{
                name: 'elem_type'
                typ:  types.Type(types.Struct{
                    name: 'ast__Type'
                })
            },
        ]
    }))
    ast_scope.insert('TypeSymbol', types.Type(types.Struct{
        name:   'ast__TypeSymbol'
        fields: [
            types.Field{
                name: 'info'
                typ:  type_info_type
            },
        ]
    }))
    type_type := types.Type(types.Struct{
        name: 'ast__Type'
    })
    mut fn_scope := types.new_scope(unsafe { nil })
    fn_scope.insert('elem_sym', types.Type(types.Pointer{
        base_type: types.Type(types.Struct{
            name: 'ast__TypeSymbol'
        })
    }))
    fn_scope.insert('elem_type', type_type)
    env := &types.Environment{}
    mut t := &Transformer{
        pref:                        &vpref.Preferences{}
        env:                         unsafe { env }
        scope:                       fn_scope
        cur_module:                  'ast'
        cached_scopes:               {
            'ast': ast_scope
        }
        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{}
        synth_types:                 map[int]types.Type{}
        smartcast_expr_counts:       map[string]int{}
    }
    info_expr := ast.Expr(ast.SelectorExpr{
        lhs: ast.Expr(ast.Ident{
            name: 'elem_sym'
        })
        rhs: ast.Ident{
            name: 'info'
        }
    })
    result := t.transform_stmt(ast.Stmt(ast.ForStmt{
        cond:  ast.Expr(ast.InfixExpr{
            op:  .key_is
            lhs: ast.Expr(ast.ModifierExpr{
                kind: .key_mut
                expr: info_expr
            })
            rhs: ast.Expr(ast.Ident{
                name: 'Array'
            })
        })
        stmts: [
            ast.Stmt(ast.AssignStmt{
                op:  .assign
                lhs: [
                    ast.Expr(ast.Ident{
                        name: 'elem_type'
                    }),
                ]
                rhs: [
                    ast.Expr(ast.SelectorExpr{
                        lhs: info_expr
                        rhs: ast.Ident{
                            name: 'elem_type'
                        }
                    }),
                ]
            }),
        ]
    }))
    assert result is ast.ForStmt
    for_stmt := result as ast.ForStmt
    assert for_stmt.stmts.len == 1
    assert for_stmt.stmts[0] is ast.AssignStmt
    assign_stmt := for_stmt.stmts[0] as ast.AssignStmt
    assert assign_stmt.rhs[0] is ast.SelectorExpr
    selector := assign_stmt.rhs[0] as ast.SelectorExpr
    assert selector.lhs is ast.CastExpr, 'selector lhs was not narrowed: ${selector.lhs.type_name()}'
    cast := selector.lhs as ast.CastExpr
    assert cast.typ.name() == 'ast__Array*'
}

fn test_checked_for_mut_selector_smartcast_rewrites_assignment_rhs_selector() {
    files := transform_code_for_test('
module main

struct Type {}

struct Array {
    elem_type Type
}

struct Struct {}

type TypeInfo = Array | Struct

struct TypeSymbol {
mut:
    info TypeInfo
}

fn f(mut elem_sym TypeSymbol) {
    mut elem_type := Type{}
    for mut elem_sym.info is Array {
        elem_type = elem_sym.info.elem_type
    }
}
')
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.name == 'f' {
                for nested in stmt.stmts {
                    if nested is ast.ForStmt {
                        assert nested.stmts.len == 1
                        assert nested.stmts[0] is ast.AssignStmt
                        assign_stmt := nested.stmts[0] as ast.AssignStmt
                        assert assign_stmt.rhs[0] is ast.SelectorExpr
                        selector := assign_stmt.rhs[0] as ast.SelectorExpr
                        assert selector.lhs is ast.CastExpr, 'selector lhs was not narrowed: ${selector.lhs.type_name()}'
                        cast := selector.lhs as ast.CastExpr
                        assert cast.typ.name() == 'Array*'
                        return
                    }
                }
            }
        }
    }
    assert false, 'function f loop was not found'
}

fn test_label_detection_ignores_empty_ast_slots() {
    assert !transformer_expr_contains_label_stmt(ast.empty_expr)
    assert !transformer_stmt_contains_label_stmt(ast.empty_stmt)
    assert !transformer_expr_contains_label_stmt(ast.IfExpr{
        cond:  ast.BasicLiteral{
            kind:  .key_true
            value: 'true'
        }
        stmts: []
    })
}

fn test_lowered_tag_check_selector_smartcast_rewrites_body_selector() {
    expr_sum_type := types.Type(types.SumType{
        name:     'ast__Expr'
        variants: [
            types.Type(types.Struct{
                name:   'ast__Ident'
                fields: [
                    types.Field{
                        name: 'language'
                        typ:  types.Type(types.Enum{
                            name: 'ast__Language'
                        })
                    },
                ]
            }),
            types.Type(types.Struct{
                name: 'ast__BasicLiteral'
            }),
        ]
    })
    mut ast_scope := types.new_scope(unsafe { nil })
    ast_scope.insert('Expr', expr_sum_type)
    ast_scope.insert('Ident', types.Type(types.Struct{
        name:   'ast__Ident'
        fields: [
            types.Field{
                name: 'language'
                typ:  types.Type(types.Enum{
                    name: 'ast__Language'
                })
            },
        ]
    }))
    ast_scope.insert('EnumField', types.Type(types.Struct{
        name:   'ast__EnumField'
        fields: [
            types.Field{
                name: 'expr'
                typ:  expr_sum_type
            },
        ]
    }))
    mut fn_scope := types.new_scope(unsafe { nil })
    fn_scope.insert('field', types.Type(types.Pointer{
        base_type: types.Type(types.Struct{
            name: 'ast__EnumField'
        })
    }))
    env := &types.Environment{}
    mut t := &Transformer{
        pref:                        &vpref.Preferences{}
        env:                         unsafe { env }
        scope:                       fn_scope
        cur_module:                  'checker'
        cached_scopes:               {
            'ast': ast_scope
        }
        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{}
        synth_types:                 map[int]types.Type{}
        smartcast_expr_counts:       map[string]int{}
    }
    field_expr := ast.Expr(ast.SelectorExpr{
        lhs: ast.Expr(ast.Ident{
            name: 'field'
        })
        rhs: ast.Ident{
            name: 'expr'
        }
    })
    result := t.transform_expr(ast.Expr(ast.IfExpr{
        cond:  ast.Expr(ast.InfixExpr{
            op:  .eq
            lhs: ast.Expr(ast.SelectorExpr{
                lhs: field_expr
                rhs: ast.Ident{
                    name: '_tag'
                }
            })
            rhs: ast.Expr(ast.BasicLiteral{
                kind:  .number
                value: '0'
            })
        })
        stmts: [
            ast.Stmt(ast.ExprStmt{
                expr: ast.Expr(ast.SelectorExpr{
                    lhs: field_expr
                    rhs: ast.Ident{
                        name: 'language'
                    }
                })
            }),
        ]
    }))
    assert result is ast.IfExpr
    if_expr := result as ast.IfExpr
    assert if_expr.stmts.len == 1
    assert if_expr.stmts[0] is ast.ExprStmt
    stmt := if_expr.stmts[0] as ast.ExprStmt
    assert stmt.expr is ast.SelectorExpr
    selector := stmt.expr as ast.SelectorExpr
    assert selector.lhs is ast.CastExpr, 'selector lhs was not narrowed: ${selector.lhs.type_name()}'
    cast := selector.lhs as ast.CastExpr
    assert cast.typ.name() == 'ast__Ident*'
}

fn test_assignment_rhs_call_or_cast_lhs_preserves_nested_smartcast() {
    stmt_sum_type := types.Type(types.SumType{
        name:     'ast__Stmt'
        variants: [
            types.Type(types.Struct{
                name: 'ast__ExprStmt'
            }),
        ]
    })
    expr_sum_type := types.Type(types.SumType{
        name:     'ast__Expr'
        variants: [
            types.Type(types.Struct{
                name: 'ast__CallExpr'
            }),
            types.Type(types.Struct{
                name: 'ast__InfixExpr'
            }),
        ]
    })
    or_expr_type := types.Type(types.Struct{
        name:   'ast__OrExpr'
        fields: [
            types.Field{
                name: 'scope'
                typ:  types.Type(types.Struct{
                    name: 'ast__Scope'
                })
            },
            types.Field{
                name: 'err_used'
                typ:  types.Type(types.bool_)
            },
        ]
    })
    mut ast_scope := types.new_scope(unsafe { nil })
    ast_scope.insert('Stmt', stmt_sum_type)
    ast_scope.insert('Expr', expr_sum_type)
    ast_scope.insert('ExprStmt', types.Type(types.Struct{
        name:   'ast__ExprStmt'
        fields: [
            types.Field{
                name: 'expr'
                typ:  expr_sum_type
            },
        ]
    }))
    ast_scope.insert('InfixExpr', types.Type(types.Struct{
        name:   'ast__InfixExpr'
        fields: [
            types.Field{
                name: 'or_block'
                typ:  or_expr_type
            },
            types.Field{
                name: 'right'
                typ:  expr_sum_type
            },
        ]
    }))
    ast_scope.insert('CallExpr', types.Type(types.Struct{
        name: 'ast__CallExpr'
    }))
    mut fn_scope := types.new_scope(unsafe { nil })
    fn_scope.insert('node', stmt_sum_type)
    env := &types.Environment{}
    mut t := &Transformer{
        pref:                        &vpref.Preferences{}
        env:                         unsafe { env }
        scope:                       fn_scope
        cur_module:                  'checker'
        cached_scopes:               {
            'ast': ast_scope
        }
        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{}
        synth_types:                 map[int]types.Type{}
        smartcast_expr_counts:       map[string]int{}
    }
    t.push_smartcast_full('node', 'ast__ExprStmt', 'ast__ExprStmt', 'ast__Stmt')
    t.push_smartcast_full('node.expr', 'ast__InfixExpr', 'ast__InfixExpr', 'ast__Expr')
    t.push_smartcast_full('node.expr.right', 'ast__CallExpr', 'ast__CallExpr', 'ast__Expr')
    node_ident := ast.Expr(ast.Ident{
        name: 'node'
    })
    node_expr := ast.Expr(ast.SelectorExpr{
        lhs: node_ident
        rhs: ast.Ident{
            name: 'expr'
        }
    })
    node_or_block := ast.Expr(ast.SelectorExpr{
        lhs: node_expr
        rhs: ast.Ident{
            name: 'or_block'
        }
    })
    node_scope := ast.Expr(ast.SelectorExpr{
        lhs: node_or_block
        rhs: ast.Ident{
            name: 'scope'
        }
    })
    transformed := t.transform_assign_stmt(ast.AssignStmt{
        op:  .assign
        lhs: [
            ast.Expr(ast.SelectorExpr{
                lhs: node_or_block
                rhs: ast.Ident{
                    name: 'err_used'
                }
            }),
        ]
        rhs: [
            ast.Expr(ast.CallOrCastExpr{
                lhs:  ast.Expr(ast.SelectorExpr{
                    lhs: node_scope
                    rhs: ast.Ident{
                        name: 'known_var'
                    }
                })
                expr: ast.Expr(ast.StringLiteral{
                    kind:  .v
                    value: "'err'"
                })
            }),
        ]
    })
    assert transformed.rhs[0] is ast.CallExpr
    call := transformed.rhs[0] as ast.CallExpr
    assert call.lhs is ast.SelectorExpr
    call_lhs := call.lhs as ast.SelectorExpr
    assert call_lhs.lhs is ast.SelectorExpr
    scope_sel := call_lhs.lhs as ast.SelectorExpr
    assert scope_sel.lhs is ast.SelectorExpr
    or_block_sel := scope_sel.lhs as ast.SelectorExpr
    assert or_block_sel.lhs is ast.CastExpr, 'rhs call lhs lost node.expr smartcast: ${or_block_sel.lhs.type_name()}'
}

fn test_transform_folds_string_literal_concat() {
    mut t := create_test_transformer()
    result := t.transform_expr(ast.InfixExpr{
        op:  .plus
        lhs: ast.Expr(ast.StringLiteral{
            kind:  .v
            value: "'left-'"
        })
        rhs: ast.Expr(ast.StringLiteral{
            kind:  .v
            value: "'right'"
        })
    })

    assert result is ast.StringLiteral, 'expected StringLiteral, got ${result.type_name()}'
    lit := result as ast.StringLiteral
    assert lit.kind == .v
    assert lit.value == 'left-right'
}

fn test_transform_keeps_generic_array_elem_equality_as_infix() {
    mut t := create_transformer_with_vars({
        'a': types.Type(types.Array{
            elem_type: types.Type(types.NamedType('T'))
        })
        'e': types.Type(types.NamedType('T'))
    })
    t.cur_fn_generic_params = ['T']
    t.generic_var_type_params = {
        'a': 'T'
    }
    t.env.set_expr_type(101, types.string_)
    t.env.set_expr_type(102, types.string_)

    result := t.transform_infix_expr(ast.InfixExpr{
        op:  .eq
        lhs: ast.Expr(ast.IndexExpr{
            lhs:  ast.Expr(ast.Ident{
                name: 'a'
            })
            expr: ast.Expr(ast.Ident{
                name: 'idx'
            })
            pos:  token.Pos{
                id: 101
            }
        })
        rhs: ast.Expr(ast.Ident{
            pos:  token.Pos{
                id: 102
            }
            name: 'e'
        })
    })

    assert result is ast.InfixExpr, 'generic equality should stay for specialized codegen'
}

fn test_transform_generic_module_call_uses_specialized_name() {
    mut t := create_test_transformer()
    mut scope := types.new_scope(unsafe { nil })
    scope.insert('json', types.Module{
        name: 'x.json2'
    })
    t.scope = scope

    result := t.transform_expr(ast.CallExpr{
        lhs:  ast.Expr(ast.GenericArgOrIndexExpr{
            lhs:  ast.Expr(ast.SelectorExpr{
                lhs: ast.Expr(ast.Ident{
                    name: 'json'
                })
                rhs: ast.Ident{
                    name: 'decode'
                }
            })
            expr: ast.Expr(ast.Ident{
                name: 'GitHubRepoInfo'
            })
        })
        args: [
            ast.Expr(ast.Ident{
                name: 'body'
            }),
        ]
    })

    assert result is ast.CallExpr, 'expected CallExpr, got ${result.type_name()}'
    call := result as ast.CallExpr
    assert call.lhs is ast.Ident
    assert (call.lhs as ast.Ident).name == 'json2__decode_T_GitHubRepoInfo'
    assert call.args.len == 1
}

fn test_transform_generic_module_call_or_cast_uses_specialized_name() {
    mut t := create_test_transformer()
    mut scope := types.new_scope(unsafe { nil })
    scope.insert('json', types.Module{
        name: 'x.json2'
    })
    t.scope = scope

    result := t.transform_expr(ast.CallOrCastExpr{
        lhs:  ast.Expr(ast.GenericArgOrIndexExpr{
            lhs:  ast.Expr(ast.SelectorExpr{
                lhs: ast.Expr(ast.Ident{
                    name: 'json'
                })
                rhs: ast.Ident{
                    name: 'decode'
                }
            })
            expr: ast.Expr(ast.Ident{
                name: 'GitHubRepoInfo'
            })
        })
        expr: ast.Expr(ast.SelectorExpr{
            lhs: ast.Expr(ast.Ident{
                name: 'resp'
            })
            rhs: ast.Ident{
                name: 'body'
            }
        })
    })

    assert result is ast.CallExpr, 'expected CallExpr, got ${result.type_name()}'
    call := result as ast.CallExpr
    assert call.lhs is ast.Ident
    assert (call.lhs as ast.Ident).name == 'json2__decode_T_GitHubRepoInfo'
    assert call.args.len == 1
}

fn test_transform_generic_module_call_or_cast_uses_array_specialized_name() {
    mut t := create_test_transformer()
    mut scope := types.new_scope(unsafe { nil })
    scope.insert('json', types.Module{
        name: 'x.json2'
    })
    t.scope = scope

    result := t.transform_expr(ast.CallOrCastExpr{
        lhs:  ast.Expr(ast.GenericArgOrIndexExpr{
            lhs:  ast.Expr(ast.SelectorExpr{
                lhs: ast.Expr(ast.Ident{
                    name: 'json'
                })
                rhs: ast.Ident{
                    name: 'decode'
                }
            })
            expr: ast.Expr(ast.Type(ast.ArrayType{
                elem_type: ast.Expr(ast.Ident{
                    name: 'GitHubContributor'
                })
            }))
        })
        expr: ast.Expr(ast.SelectorExpr{
            lhs: ast.Expr(ast.Ident{
                name: 'resp'
            })
            rhs: ast.Ident{
                name: 'body'
            }
        })
    })

    assert result is ast.CallExpr, 'expected CallExpr, got ${result.type_name()}'
    call := result as ast.CallExpr
    assert call.lhs is ast.Ident
    assert (call.lhs as ast.Ident).name == 'json2__decode_T_Array_GitHubContributor'
    assert call.args.len == 1
}

fn test_transform_monomorphizes_imported_generic_module_call() {
    files := transform_sources_for_test([
        TestSource{
            rel:  'x/json2/decode.v'
            code: '
module json2

struct Decoder {}

fn (mut decoder Decoder) decode_value[T](mut value T) ! {
    _ = value
}

pub fn decode[T]() !T {
    mut decoder := Decoder{}
    mut result := T{}
    decoder.decode_value(mut result)!
    return result
}
'
        },
        TestSource{
            rel:  'main.v'
            code: '
module main

import x.json2

struct Payload {
    value int
}

fn main() {
    _ := json2.decode[Payload]() or { Payload{} }
}
'
        },
    ])
    call_names := call_names_for_fn(files, 'main')
    assert 'json2__decode_T_Payload' in call_names
    assert 'decode_T_Payload' !in call_names

    mut found_prefixed_clone := false
    mut found_unprefixed_clone := false
    mut found_method_clone := false
    mut found_generic_decl := false
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl {
                if stmt.name == 'json2__decode_T_Payload' {
                    found_prefixed_clone = true
                    assert stmt.typ.generic_params.len == 0
                }
                if stmt.name == 'decode_T_Payload' {
                    found_unprefixed_clone = true
                }
                if stmt.name == 'decode_value_T_Payload' {
                    found_method_clone = true
                    assert stmt.typ.generic_params.len == 0
                }
                if stmt.name == 'decode' && decl_generic_param_names(stmt).len > 0 {
                    found_generic_decl = true
                }
            }
        }
    }
    assert found_prefixed_clone
    assert !found_unprefixed_clone
    assert found_method_clone
    assert !found_generic_decl
}

fn test_transform_nested_module_selector_respects_local_shadow() {
    mut t := create_test_transformer()
    mut checker_scope := types.new_scope(unsafe { nil })
    checker_scope.insert('checker', types.Module{
        name: 'checker'
    })
    mut fn_scope := types.new_scope(checker_scope)
    fn_scope.insert('checker', types.Type(types.Struct{
        name: 'checker__Checker'
    }))
    t.cur_module = 'checker'
    t.scope = fn_scope
    t.cached_scopes = {
        'checker':       checker_scope
        'type_resolver': types.new_scope(unsafe { nil })
    }

    result := t.transform_expr(ast.SelectorExpr{
        lhs: ast.Expr(ast.SelectorExpr{
            lhs: ast.Expr(ast.Ident{
                name: 'checker'
            })
            rhs: ast.Ident{
                name: 'type_resolver'
            }
        })
        rhs: ast.Ident{
            name: 'info'
        }
    })

    assert result is ast.SelectorExpr, 'local field chain must not become a module symbol'
    outer := result as ast.SelectorExpr
    assert outer.lhs is ast.SelectorExpr
    inner := outer.lhs as ast.SelectorExpr
    assert inner.lhs is ast.Ident
    assert (inner.lhs as ast.Ident).name == 'checker'
    assert inner.rhs.name == 'type_resolver'
    assert outer.rhs.name == 'info'
}

fn test_expr_to_string_keeps_as_cast_selector_paths_distinct() {
    t := create_test_transformer()
    node_right := ast.Expr(ast.SelectorExpr{
        lhs: ast.Expr(ast.Ident{
            name: 'node'
        })
        rhs: ast.Ident{
            name: 'right'
        }
    })
    ast_as_cast := ast.Expr(ast.SelectorExpr{
        lhs: ast.Expr(ast.Ident{
            name: 'ast'
        })
        rhs: ast.Ident{
            name: 'AsCast'
        }
    })
    ast_par_expr := ast.Expr(ast.SelectorExpr{
        lhs: ast.Expr(ast.Ident{
            name: 'ast'
        })
        rhs: ast.Ident{
            name: 'ParExpr'
        }
    })
    as_cast_payload_expr := ast.Expr(ast.SelectorExpr{
        lhs: ast.Expr(ast.AsCastExpr{
            expr: ast.Expr(ast.SelectorExpr{
                lhs: node_right
                rhs: ast.Ident{
                    name: 'expr'
                }
            })
            typ:  ast_as_cast
        })
        rhs: ast.Ident{
            name: 'expr'
        }
    })
    par_expr_payload_expr := ast.Expr(ast.SelectorExpr{
        lhs: ast.Expr(ast.AsCastExpr{
            expr: node_right
            typ:  ast_par_expr
        })
        rhs: ast.Ident{
            name: 'expr'
        }
    })

    assert t.expr_to_string(as_cast_payload_expr) == '(node.right.expr as ast__AsCast).expr'
    assert t.expr_to_string(par_expr_payload_expr) == '(node.right as ast__ParExpr).expr'
    assert t.expr_to_string(as_cast_payload_expr) != t.expr_to_string(par_expr_payload_expr)
}

fn test_transform_bare_generic_call_uses_specialized_name() {
    mut t := create_test_transformer()
    result := t.transform_expr(ast.CallExpr{
        lhs:  ast.Expr(ast.GenericArgs{
            lhs:  ast.Expr(ast.Ident{
                name: 'run_new'
            })
            args: [
                ast.Expr(ast.Ident{
                    name: 'A'
                }),
                ast.Expr(ast.Ident{
                    name: 'X'
                }),
            ]
        })
        args: [
            ast.Expr(ast.Ident{
                name: 'app'
            }),
            ast.Expr(ast.Ident{
                name: 'params'
            }),
        ]
    })

    assert result is ast.CallExpr, 'expected CallExpr, got ${result.type_name()}'
    call := result as ast.CallExpr
    assert call.lhs is ast.Ident
    assert (call.lhs as ast.Ident).name == 'run_new_T_A_X'
    assert call.args.len == 2
}

fn test_transform_transitive_generic_call_in_clone_emits_callee_clone() {
    files := transform_sources_for_test([
        TestSource{
            rel:  'webx/webx.v'
            code: 'module webx

pub fn run_at[A, X]() ! {
    run_new[A, X]()!
}

pub fn run_new[A, X]() ! {}
'
        },
        TestSource{
            rel:  'main.v'
            code: 'module main

import webx

struct App {}
struct Context {}

fn boot() {
    webx.run_at[App, Context]() or {}
}
'
        },
    ])
    mut fn_names := []string{}
    mut webx_fn_names := []string{}
    mut main_fn_names := []string{}
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl {
                fn_names << stmt.name
                if file.mod == 'webx' {
                    webx_fn_names << stmt.name
                }
                if file.mod == 'main' {
                    main_fn_names << stmt.name
                }
            }
        }
    }
    assert 'webx__run_at_T_App_Context' in fn_names
    assert 'webx__run_new_T_App_Context' in fn_names
    assert 'webx__run_at_T_App_Context' in main_fn_names
    assert 'webx__run_new_T_App_Context' in main_fn_names
    assert 'webx__run_at_T_App_Context' !in webx_fn_names
    assert 'webx__run_new_T_App_Context' !in webx_fn_names
}

fn test_transform_transitive_generic_call_with_mut_arg_in_clone_emits_callee_clone() {
    files := transform_sources_for_test([
        TestSource{
            rel:  'webx/webx.v'
            code: 'module webx

pub struct RunParams {}

pub fn run_at[A, X](mut global_app A, params RunParams) ! {
    run_new[A, X](mut global_app, params)!
}

pub fn run_new[A, X](mut global_app A, params RunParams) ! {}
'
        },
        TestSource{
            rel:  'main.v'
            code: 'module main

import webx

struct App {}
struct Context {}

fn boot() {
    mut app := App{}
    webx.run_at[App, Context](mut app, webx.RunParams{}) or {}
}
'
        },
    ])
    mut fn_names := []string{}
    mut webx_fn_names := []string{}
    mut main_fn_names := []string{}
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl {
                fn_names << stmt.name
                if file.mod == 'webx' {
                    webx_fn_names << stmt.name
                }
                if file.mod == 'main' {
                    main_fn_names << stmt.name
                }
            }
        }
    }
    assert 'webx__run_at_T_App_Context' in fn_names
    assert 'webx__run_new_T_App_Context' in fn_names
    assert 'webx__run_at_T_App_Context' in main_fn_names
    assert 'webx__run_new_T_App_Context' in main_fn_names
    assert 'webx__run_at_T_App_Context' !in webx_fn_names
    assert 'webx__run_new_T_App_Context' !in webx_fn_names
}

fn test_transform_transitive_generic_function_value_in_clone_emits_full_callee_clone() {
    files := transform_sources_for_test([
        TestSource{
            rel:  'webx/webx.v'
            code: 'module webx

pub struct ServerConfig {
    handler fn (req int) int
}

pub struct Context {}

pub fn run_at[A, X]() {
    run_new[A, X]()
}

pub fn run_new[A, X]() {
    _ := ServerConfig{
        handler: parallel_request_handler[A, X]
    }
}

fn parallel_request_handler[A, X](req int) int {
    return route[A, X](req)
}

fn route[A, X](req int) int {
    return req
}
'
        },
        TestSource{
            rel:  'main.v'
            code: 'module main

import webx

struct App {}
struct Context {}

fn boot() {
    webx.run_at[App, Context]()
}
'
        },
    ])
    mut main_fn_names := []string{}
    mut handler_name := ''
    for file in files {
        if file.mod != 'main' {
            continue
        }
        for stmt in file.stmts {
            if stmt is ast.FnDecl {
                main_fn_names << stmt.name
                if stmt.name == 'webx__run_new_T_App_Context' {
                    assign := stmt.stmts[0] as ast.AssignStmt
                    init := assign.rhs[0] as ast.InitExpr
                    if init.fields[0].value is ast.Ident {
                        handler_name = (init.fields[0].value as ast.Ident).name
                    } else {
                        handler_name = init.fields[0].value.type_name()
                    }
                }
            }
        }
    }
    assert 'webx__run_new_T_App_Context' in main_fn_names
    assert handler_name == 'webx__parallel_request_handler_T_App_Context'
    assert 'webx__parallel_request_handler_T_App_Context' in main_fn_names
    assert 'webx__route_T_App_Context' in main_fn_names
}

fn test_transform_imported_clone_substituted_init_type_keeps_declaring_module_context() {
    files := transform_sources_for_test([
        TestSource{
            rel:  'webx/webx.v'
            code: 'module webx

pub struct Context {}

pub fn make[A, X]() {
    ctx := &Context{}
    mut user_context := X{
        Context: ctx
    }
    route[A, X](mut user_context)
}

fn route[A, X](mut user_context X) {
    _ = user_context
}
'
        },
        TestSource{
            rel:  'main.v'
            code: 'module main

import webx

struct App {}

struct Context {
    webx.Context
}

fn boot() {
    webx.make[App, Context]()
}
'
        },
    ])
    mut init_type_name := ''
    mut main_fn_names := []string{}
    for file in files {
        if file.mod != 'main' {
            continue
        }
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.name == 'webx__make_T_App_Context' {
                main_fn_names << stmt.name
                assign := stmt.stmts[1] as ast.AssignStmt
                init := assign.rhs[0] as ast.InitExpr
                init_type := init.typ as ast.Ident
                init_type_name = init_type.name
            } else if stmt is ast.FnDecl {
                main_fn_names << stmt.name
            }
        }
    }
    assert init_type_name == 'Context'
    assert 'webx__route_T_App_Context' in main_fn_names
}

fn test_transform_generic_struct_clone_qualifies_module_type_arg_in_fn_field() {
    files := transform_sources_for_test([
        TestSource{
            rel:  'veb/veb.v'
            code: 'module veb

pub struct Context {}

pub struct MiddlewareOptions[T] {
    handler fn (mut ctx T) bool
}

pub fn make[T]() MiddlewareOptions[T] {
    return MiddlewareOptions[T]{}
}
'
        },
        TestSource{
            rel:  'main.v'
            code: 'module main

import veb

struct Context {}

fn boot() {
    _ := veb.make[veb.Context]()
}
'
        },
    ])
    mut clone_name := ''
    mut handler_param_name := ''
    for file in files {
        if file.mod != 'veb' {
            continue
        }
        for stmt in file.stmts {
            if stmt is ast.StructDecl && stmt.name == 'MiddlewareOptions_T_veb_Context' {
                clone_name = stmt.name
                field_typ := stmt.fields[0].typ as ast.Type
                fn_typ := field_typ as ast.FnType
                param_ident := fn_typ.params[0].typ as ast.Ident
                handler_param_name = param_ident.name
            }
        }
    }
    assert clone_name == 'MiddlewareOptions_T_veb_Context'
    assert handler_param_name == 'veb__Context'
}

fn test_transform_embedded_generic_method_options_do_not_emit_bare_import_context() {
    files := transform_sources_for_test([
        TestSource{
            rel:  'veb/veb.v'
            code: 'module veb

pub struct Context {}

pub struct Middleware[T] {}

@[params]
pub struct MiddlewareOptions[T] {
    handler fn (mut ctx T) bool
}

pub fn (mut m Middleware[T]) use(options MiddlewareOptions[T]) {
    _ = options
}
'
        },
        TestSource{
            rel:  'main.v'
            code: 'module main

import veb

struct App {
    veb.Middleware[Context]
}

struct Context {
    veb.Context
}

fn (app &App) before_request(mut ctx Context) bool {
    return true
}

fn boot() {
    mut app := App{}
    app.use(handler: app.before_request)
}
'
        },
    ])
    mut import_handler_param := ''
    mut main_handler_param := ''
    for file in files {
        for stmt in file.stmts {
            match stmt {
                ast.StructDecl {
                    if !stmt.name.contains('MiddlewareOptions_T') {
                        continue
                    }
                    field_typ := stmt.fields[0].typ as ast.Type
                    fn_typ := field_typ as ast.FnType
                    param_ident := fn_typ.params[0].typ as ast.Ident
                    if file.mod == 'veb' && stmt.name == 'MiddlewareOptions_T_veb_Context' {
                        import_handler_param = param_ident.name
                    }
                    if file.mod == 'main' && stmt.name == 'veb__MiddlewareOptions_T_Context' {
                        main_handler_param = param_ident.name
                    }
                }
                else {}
            }
        }
    }
    assert import_handler_param == '' || import_handler_param == 'veb__Context', 'import_handler_param=${import_handler_param}, main_handler_param=${main_handler_param}'

    assert main_handler_param == '' || main_handler_param == 'Context', 'import_handler_param=${import_handler_param}, main_handler_param=${main_handler_param}'
}

fn test_transform_imported_generic_struct_with_local_type_stays_in_call_file() {
    files := transform_sources_for_test([
        TestSource{
            rel:  'json2/json2.v'
            code: 'module json2

pub struct StructKeyDecodeResult[T] {
    value T
}

pub fn decode[T]() StructKeyDecodeResult[T] {
    return StructKeyDecodeResult[T]{}
}
'
        },
        TestSource{
            rel:  'main.v'
            code: 'module main

import json2

struct LocalResponse {}

fn boot() {
    _ := json2.decode[LocalResponse]()
}
'
        },
    ])
    mut import_struct_found := false
    mut import_fn_found := false
    mut main_struct_found := false
    mut main_fn_found := false
    mut main_field_typ := ''
    for file in files {
        for stmt in file.stmts {
            match stmt {
                ast.StructDecl {
                    if stmt.name == 'json2__StructKeyDecodeResult_T_LocalResponse'
                        || stmt.name == 'StructKeyDecodeResult_T_LocalResponse' {
                        if file.mod == 'json2' {
                            import_struct_found = true
                        }
                        if file.mod == 'main'
                            && stmt.name == 'json2__StructKeyDecodeResult_T_LocalResponse' {
                            main_struct_found = true
                            field_typ := stmt.fields[0].typ as ast.Ident
                            main_field_typ = field_typ.name
                        }
                    }
                }
                ast.FnDecl {
                    if stmt.name == 'json2__decode_T_LocalResponse'
                        || stmt.name == 'decode_T_LocalResponse' {
                        if file.mod == 'json2' {
                            import_fn_found = true
                        }
                        if file.mod == 'main' && stmt.name == 'json2__decode_T_LocalResponse' {
                            main_fn_found = true
                        }
                    }
                }
                else {}
            }
        }
    }
    assert !import_struct_found
    assert !import_fn_found
    assert main_struct_found
    assert main_fn_found
    assert main_field_typ == 'LocalResponse'
}

fn test_transform_generic_struct_emits_module_clone_after_file_local_clone() {
    files := transform_sources_for_test([
        TestSource{
            rel:  'other/other.v'
            code: 'module other

pub struct Type {}
'
        },
        TestSource{
            rel:  'm/m.v'
            code: 'module m

import other

pub struct Box[T] {
    value T
}

pub fn use_external() Box[other.Type] {
    return Box[other.Type]{}
}

pub fn use_int() Box[int] {
    return Box[int]{}
}
'
        },
        TestSource{
            rel:  'main.v'
            code: 'module main

import m

fn boot() {
    _ := m.use_external()
    _ := m.use_int()
}
'
        },
    ])
    mut m_structs := []string{}
    for file in files {
        if file.mod != 'm' {
            continue
        }
        for stmt in file.stmts {
            if stmt is ast.StructDecl {
                m_structs << stmt.name
            }
        }
    }
    assert 'Box_T_other_Type' in m_structs
    assert 'Box_T_int' in m_structs
}

fn test_transform_moved_generic_struct_qualifies_source_module_field_types() {
    files := transform_sources_for_test([
        TestSource{
            rel:  'boxlib/boxlib.v'
            code: 'module boxlib

pub struct Helper {}

pub struct Box[T] {
    Helper
    helper Helper
    values []Helper
    value T
}

pub fn make[T]() Box[T] {
    return Box[T]{}
}
'
        },
        TestSource{
            rel:  'main.v'
            code: 'module main

import boxlib

struct LocalResponse {}

fn boot() {
    _ := boxlib.make[LocalResponse]()
}
'
        },
    ])
    mut moved_struct_found := false
    mut embedded_typ := ''
    mut helper_typ := ''
    mut values_elem_typ := ''
    mut value_typ := ''
    for file in files {
        if file.mod != 'main' {
            continue
        }
        for stmt in file.stmts {
            if stmt is ast.StructDecl && stmt.name == 'boxlib__Box_T_LocalResponse' {
                moved_struct_found = true
                if stmt.embedded.len > 0 {
                    embedded_ident := stmt.embedded[0] as ast.Ident
                    embedded_typ = embedded_ident.name
                }
                for field in stmt.fields {
                    match field.name {
                        'helper' {
                            helper_ident := field.typ as ast.Ident
                            helper_typ = helper_ident.name
                        }
                        'values' {
                            array_typ := field.typ as ast.Type
                            values_array := array_typ as ast.ArrayType
                            values_elem_ident := values_array.elem_type as ast.Ident
                            values_elem_typ = values_elem_ident.name
                        }
                        'value' {
                            value_ident := field.typ as ast.Ident
                            value_typ = value_ident.name
                        }
                        else {}
                    }
                }
            }
        }
    }
    assert moved_struct_found
    assert embedded_typ == 'boxlib__Helper'
    assert helper_typ == 'boxlib__Helper'
    assert values_elem_typ == 'boxlib__Helper'
    assert value_typ == 'LocalResponse'
}

fn test_transform_transitive_imported_clone_substitutes_nested_generic_route_context() {
    env, files := transform_sources_with_env_for_test([
        TestSource{
            rel:  'webx/webx.v'
            code: 'module webx

pub struct Request {
    route int
}

pub struct ServerConfig {
    handler fn (req Request) &Context
}

pub struct Context {
    current_path string
}

pub fn run_new[A, X](mut global_app A) {
    _ := ServerConfig{
        handler: parallel_request_handler[A, X]
    }
    _ = global_app
}

fn parallel_request_handler[A, X](req Request) &Context {
    mut app := A{}
    return handle_request_and_route[A, X](mut app, req)
}

fn handle_request_and_route[A, X](mut app A, req Request) &Context {
    mut ctx := &Context{}
    mut user_context := X{
        Context: ctx
    }
    handle_route[A, X](mut app, mut user_context, req.route)
    return ctx
}

fn handle_route[A, X](mut app A, mut user_context X, route int) {
    _ = app
    _ = user_context
    _ = route
}
'
        },
        TestSource{
            rel:  'main.v'
            code: 'module main

import webx

struct App {}

struct Context {
    webx.Context
}

fn boot() {
    mut app := App{}
    webx.run_new[App, Context](mut app)
}
'
        },
    ])
    mut main_fn_names := []string{}
    mut init_type_name := ''
    mut route_call_name := ''
    for file in files {
        if file.mod != 'main' {
            continue
        }
        for stmt in file.stmts {
            if stmt is ast.FnDecl {
                main_fn_names << stmt.name
                if stmt.name == 'webx__handle_request_and_route_T_App_Context' {
                    for inner in stmt.stmts {
                        if inner is ast.AssignStmt && inner.lhs.len == 1 && inner.rhs.len == 1 {
                            lhs_name := ident_name_from_expr_for_test(inner.lhs[0]) or { '' }
                            if lhs_name == 'user_context' && inner.rhs[0] is ast.InitExpr {
                                init := inner.rhs[0] as ast.InitExpr
                                init_type := init.typ as ast.Ident
                                init_type_name = init_type.name
                            }
                        }
                        if inner is ast.ExprStmt && inner.expr is ast.CallExpr {
                            call := inner.expr as ast.CallExpr
                            if call.lhs is ast.Ident {
                                route_call_name = (call.lhs as ast.Ident).name
                            } else {
                                route_call_name = call.lhs.type_name()
                            }
                        }
                    }
                }
            }
        }
    }
    assert 'webx__parallel_request_handler_T_App_Context' in main_fn_names
    assert 'webx__handle_request_and_route_T_App_Context' in main_fn_names
    assert 'webx__handle_route_T_App_Context' in main_fn_names
    assert init_type_name == 'Context'
    assert route_call_name == 'webx__handle_route_T_App_Context'
    route_scope := env.get_fn_scope('main', 'webx__handle_route_T_App_Context') or {
        panic('missing imported route clone scope')
    }
    user_context_type := route_scope.lookup_var_type('user_context') or {
        panic('missing user_context type')
    }
    assert user_context_type.name() == 'Context'
}

fn test_transform_inferred_generic_method_call_uses_specialized_name() {
    files := transform_code_for_test('
module main

struct Job {}

struct Item {
    value int
}

struct Out {
mut:
    value int
}

fn fill(item Item, mut out Out) {
    out.value = item.value
}

fn (job &Job) apply[K, D, F](items []K, mut out []D, f F) {
    _ = job
    if items.len > 0 && out.len > 0 {
        f(items[0], mut out[0])
    }
}

fn use_apply() int {
    job := Job{}
    items := [Item{
        value: 7
    }]
    mut out := []Out{len: 1}
    job.apply(items, mut out, fill)
    return out[0].value
}
')
    call_names := call_names_for_fn(files, 'use_apply')
    assert 'Job__apply_T_Item_Out_fn_item_Item_out_Out_void' in call_names
    assert 'Job__apply' !in call_names

    mut found_clone := false
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.name == 'apply_T_Item_Out_fn_item_Item_out_Out_void' {
                found_clone = true
                assert stmt.typ.generic_params.len == 0
                assert stmt.typ.params.len == 3
                assert stmt.typ.params[2].typ is ast.Type
                fn_param_type := stmt.typ.params[2].typ as ast.Type
                assert fn_param_type is ast.FnType
            }
        }
    }
    assert found_clone
}

fn test_transform_non_generic_method_does_not_match_generic_method_short_name() {
    files := transform_code_for_test('
module main

struct Vec3[T] {
    x T
    y T
    z T
}

fn (v Vec3[T]) div(u Vec3[T]) Vec3[T] {
    _ = u
    return v
}

struct Float3 {
    x f32
    y f32
    z f32
}

fn (a Float3) div(s f32) Float3 {
    _ = s
    return a
}

fn use_float(a Float3) {
    _ = a.div(f32(2))
}
')
    call_names := call_names_for_fn(files, 'use_float')
    assert 'Float3__div' in call_names
    assert 'Float3__div_T_f32' !in call_names
}

fn test_transform_inferred_generic_fn_call_uses_specialized_fn_arg_name() {
    files := transform_code_for_test('
module main

struct Alpha {}

fn use_alpha(mut a Alpha) {
    _ = a
}

fn call_cb[T, F](mut value T, cb F) {
    cb(mut value)
}

fn main() {
    mut a := Alpha{}
    call_cb(mut a, use_alpha)
}
')
    call_names := call_names_for_fn(files, 'main')
    assert 'call_cb_T_Alpha_fn_a_Alpha_void' in call_names
    assert 'call_cb' !in call_names
    assert 'call_cb_T_Alpha_voidptr' !in call_names
}

fn test_transform_records_inferred_generic_binding_before_monomorphize() {
    files := transform_code_for_test('
module main

fn clamp[T](a T, x T, b T) T {
    mut min := T(0)
    if x < b {
        min = x
    } else {
        min = b
    }
    return if min < a { a } else { min }
}

fn main() {
    ratio := f32(0.5)
    _ = clamp(f32(0), ratio, 1.0)
}
')
    call_names := call_names_for_fn(files, 'main')
    assert 'clamp_T_f32' in call_names
    mut found_clone := false
    for file in files {
        for stmt in file.stmts {
            if stmt is ast.FnDecl && stmt.name == 'clamp_T_f32' {
                found_clone = true
                assert stmt.typ.generic_params.len == 0
                assert stmt.stmts.len > 0
            }
        }
    }
    assert found_clone
}

fn stmts_have_defer(stmts []ast.Stmt) bool {
    for stmt in stmts {
        match stmt {
            ast.BlockStmt {
                if stmts_have_defer(stmt.stmts) {
                    return true
                }
            }
            ast.ComptimeStmt {
                if stmts_have_defer([stmt.stmt]) {
                    return true
                }
            }
            ast.DeferStmt {
                return true
            }
            ast.ExprStmt {
                if stmt.expr is ast.IfExpr {
                    if stmts_have_defer(stmt.expr.stmts) {
                        return true
                    }
                }
            }
            ast.ForStmt {
                if stmts_have_defer(stmt.stmts) {
                    return true
                }
            }
            else {}
        }
    }
    return false
}

fn test_lower_defer_stmts_lowers_defer_inside_comptime_stmt() {
    mut t := create_test_transformer()
    cleanup_stmt := ast.Stmt(ast.ExprStmt{
        expr: ast.Expr(ast.Ident{
            name: 'cleanup'
        })
    })
    body_stmt := ast.Stmt(ast.ExprStmt{
        expr: ast.Expr(ast.Ident{
            name: 'body'
        })
    })
    lowered := t.lower_defer_stmts([
        ast.Stmt(ast.ComptimeStmt{
            stmt: ast.Stmt(ast.ForStmt{
                stmts: [
                    body_stmt,
                    ast.Stmt(ast.DeferStmt{
                        stmts: [cleanup_stmt]
                    }),
                ]
            })
        }),
    ], false, types.Type(types.void_))

    assert !stmts_have_defer(lowered)
    assert lowered.len == 1
    assert lowered[0] is ast.ComptimeStmt
    comptime_stmt := lowered[0] as ast.ComptimeStmt
    assert comptime_stmt.stmt is ast.ForStmt
    for_stmt := comptime_stmt.stmt as ast.ForStmt
    assert for_stmt.stmts.len == 2
    assert for_stmt.stmts[1] is ast.ExprStmt
    assert (for_stmt.stmts[1] as ast.ExprStmt).expr.name() == 'cleanup'
}

fn test_lower_defer_fn_inside_loop_runs_on_function_exit() {
    mut t := create_test_transformer()
    cleanup_stmt := ast.Stmt(ast.ExprStmt{
        expr: ast.Expr(ast.Ident{
            name: 'cleanup'
        })
    })
    body_stmt := ast.Stmt(ast.ExprStmt{
        expr: ast.Expr(ast.Ident{
            name: 'body'
        })
    })
    lowered := t.lower_defer_stmts([
        ast.Stmt(ast.ForStmt{
            stmts: [
                ast.Stmt(ast.DeferStmt{
                    mode:  .function
                    stmts: [cleanup_stmt]
                }),
                body_stmt,
            ]
        }),
        ast.Stmt(ast.ReturnStmt{
            exprs: [
                ast.Expr(ast.Ident{
                    name: 'x'
                }),
            ]
        }),
    ], true, types.Type(types.int_))

    assert !stmts_have_defer(lowered)
    assert lowered.len == 5
    assert lowered[0] is ast.AssignStmt
    flag_decl := lowered[0] as ast.AssignStmt
    assert flag_decl.op == .decl_assign
    assert flag_decl.lhs[0] is ast.Ident
    flag_name := (flag_decl.lhs[0] as ast.Ident).name

    assert lowered[1] is ast.ForStmt
    for_stmt := lowered[1] as ast.ForStmt
    assert for_stmt.stmts.len == 2
    assert for_stmt.stmts[0] is ast.AssignStmt
    flag_assign := for_stmt.stmts[0] as ast.AssignStmt
    assert flag_assign.op == .assign
    assert flag_assign.lhs[0] is ast.Ident
    assert (flag_assign.lhs[0] as ast.Ident).name == flag_name
    assert for_stmt.stmts[1] is ast.ExprStmt
    assert (for_stmt.stmts[1] as ast.ExprStmt).expr.name() == 'body'

    assert lowered[3] is ast.ExprStmt
    guard_stmt := lowered[3] as ast.ExprStmt
    assert guard_stmt.expr is ast.IfExpr
    guard := guard_stmt.expr as ast.IfExpr
    assert guard.cond is ast.Ident
    assert (guard.cond as ast.Ident).name == flag_name
    assert guard.stmts.len == 1
    assert guard.stmts[0] is ast.ExprStmt
    assert (guard.stmts[0] as ast.ExprStmt).expr.name() == 'cleanup'
}

fn test_defer_return_temp_uses_value_type_for_pointer_expr_returning_value() {
    mut scope := types.new_scope(unsafe { nil })
    mut env := types.Environment.new()
    stmt_type := types.Type(types.SumType{
        name: 'ast__Stmt'
    })
    ptr_stmt_type := types.Type(types.Pointer{
        base_type: stmt_type
    })
    pos := token.Pos{
        id: 99101
    }
    env.set_expr_type(pos.id, ptr_stmt_type)
    mut t := &Transformer{
        pref:                        &vpref.Preferences{}
        env:                         unsafe { env }
        scope:                       scope
        fn_root_scope:               scope
        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{}
        local_decl_types:            map[string]types.Type{}
    }
    t.register_defer_return_temp('_defer_t1', ast.Expr(ast.Ident{
        name: 'node'
        pos:  pos
    }), stmt_type, map[string]types.Type{})
    obj := scope.lookup_parent('_defer_t1', 0) or { panic('missing defer temp') }
    assert obj.typ().name() == 'ast__Stmt'
}

fn test_defer_return_temp_uses_sum_return_type_for_smartcast_variant() {
    temp_type := defer_return_temp_type(types.Type(types.Struct{
        name: 'ast__ForStmt'
    }), types.Type(types.SumType{
        name:     'ast__Stmt'
        variants: [
            types.Type(types.Struct{
                name: 'ast__ForCStmt'
            }),
            types.Type(types.Struct{
                name: 'ast__ForInStmt'
            }),
            types.Type(types.Struct{
                name: 'ast__ForStmt'
            }),
        ]
    }))
    assert temp_type.name() == 'ast__Stmt'
}

fn test_transform_persists_defer_return_temp_scope_for_codegen() {
    env, _ := transform_code_with_env_for_test('
type Stmt = EmptyStmt | ForInStmt

struct EmptyStmt {}

struct ForInStmt {
    val int
}

struct G {
mut:
    values map[string]int
}

fn cleanup() {}

fn (mut g G) stmt(node Stmt) Stmt {
    if node is ForInStmt {
        defer(fn) {
            cleanup()
        }
        mut new_node := ForInStmt{
            ...node
        }
        return Stmt(new_node)
    }
    return node
}
')
    fn_scope := env.get_fn_scope('main', 'G__stmt') or { panic('missing transformed fn scope') }
    mut found_defer_temp := false
    for name, obj in fn_scope.objects {
        if !name.starts_with('_defer_t') {
            continue
        }
        found_defer_temp = true
        assert obj.typ() !is types.Pointer
        assert obj.typ().name().ends_with('Stmt')
    }
    assert found_defer_temp
}

fn test_scoped_defer_return_err_temp_uses_ierror_type() {
    mut scope := types.new_scope(unsafe { nil })
    mut t := create_test_transformer()
    t.scope = scope
    t.fn_root_scope = scope
    t.set_synth_pos_counter(-1)
    err_type := types.Type(types.Struct{
        name: 'IError'
    })
    t.register_defer_return_temp('_defer_t_err', ast.Expr(ast.Ident{
        name: 'err'
    }), types.Type(types.ResultType{
        base_type: types.Type(types.SumType{
            name: 'ast__Expr'
        })
    }), {
        'err': err_type
    })
    mut found_ierror_temp := false
    mut temp_types := []string{}
    for name, obj in scope.objects {
        if !name.starts_with('_defer_t') {
            continue
        }
        temp_types << '${name}:${obj.typ().name()}'
        if obj.typ().name() == 'IError' {
            found_ierror_temp = true
        }
    }
    assert found_ierror_temp, temp_types.str()
}

fn test_defer_decl_tracking_prefers_rhs_type_for_err_decl() {
    mut scope := types.new_scope(unsafe { nil })
    scope.insert_or_update('err', types.Type(types.Struct{
        name: 'ast__NodeError'
    }))
    mut t := create_test_transformer()
    t.scope = scope
    t.set_synth_pos_counter(-1)
    t.synth_types = map[int]types.Type{}
    or_tmp := ast.Expr(ast.Ident{
        name: '_or_t1'
    })
    mut decls := map[string]types.Type{}
    t.add_decl_types_from_stmt(mut decls, ast.Stmt(ast.AssignStmt{
        op:  .decl_assign
        lhs: [ast.Expr(ast.Ident{
            name: 'err'
        })]
        rhs: [
            t.synth_selector(or_tmp, 'err', types.Type(types.Struct{
                name: 'IError'
            })),
        ]
    }))
    err_type := decls['err'] or {
        assert false, 'err declaration type was not tracked'
        return
    }
    assert err_type.name() == 'IError'
}

fn test_transform_string_inter_smartcast_temp_uses_variant_type() {
    env, _ := transform_code_with_env_for_test('
type Value = int | string

struct Entry {
    key Value
}

fn entry_string(entry Entry) string {
    key_text := if entry.key is string {
        "\${entry.key}"
    } else {
        "other"
    }
    return key_text
}
')
    fn_scope := env.get_fn_scope('main', 'entry_string') or {
        panic('missing transformed fn scope')
    }
    mut found_string_temp := false
    for name, obj in fn_scope.objects {
        if !name.starts_with('_or_t') {
            continue
        }
        if obj.typ().name() == 'string' {
            found_string_temp = true
        }
        assert obj.typ().name() != 'Value'
    }
    assert found_string_temp
}

fn test_lower_defer_fn_captures_block_local_values() {
    mut t := create_transformer_with_vars({
        'old': types.Type(types.bool_)
    })
    old_decl := ast.Stmt(ast.AssignStmt{
        op:  .decl_assign
        lhs: [ast.Expr(ast.Ident{
            name: 'old'
        })]
        rhs: [ast.Expr(ast.BasicLiteral{
            kind:  .key_false
            value: 'false'
        })]
    })
    defer_stmt := ast.Stmt(ast.DeferStmt{
        mode:  .function
        stmts: [
            ast.Stmt(ast.AssignStmt{
                op:  .assign
                lhs: [
                    ast.Expr(ast.SelectorExpr{
                        lhs: ast.Ident{
                            name: 'g'
                        }
                        rhs: ast.Ident{
                            name: 'inside_smartcast'
                        }
                    }),
                ]
                rhs: [
                    ast.Expr(ast.Ident{
                        name: 'old'
                    }),
                ]
            }),
        ]
    })
    lowered := t.lower_defer_stmts([
        ast.Stmt(ast.BlockStmt{
            stmts: [old_decl, defer_stmt]
        }),
    ], false, types.Type(types.void_))

    assert lowered.len == 4
    assert lowered[1] is ast.AssignStmt
    capture_decl := lowered[1] as ast.AssignStmt
    assert capture_decl.lhs[0] is ast.Ident
    capture_name := (capture_decl.lhs[0] as ast.Ident).name
    assert capture_name.starts_with('_defer_cap')

    assert lowered[2] is ast.BlockStmt
    block_stmt := lowered[2] as ast.BlockStmt
    assert block_stmt.stmts.len == 3
    assert block_stmt.stmts[1] is ast.AssignStmt
    capture_assign := block_stmt.stmts[1] as ast.AssignStmt
    assert capture_assign.lhs[0] is ast.Ident
    assert (capture_assign.lhs[0] as ast.Ident).name == capture_name

    assert lowered[3] is ast.ExprStmt
    guard := (lowered[3] as ast.ExprStmt).expr as ast.IfExpr
    restore := guard.stmts[0] as ast.AssignStmt
4418<