module eval

import os
import v3.parser

const vexe = @VEXE
const v3_dir = os.dir(os.dir(@FILE))
const v3_src = os.join_path(v3_dir, 'v3.v')

fn test_eval_function_call_and_for_range() {
    mut e := create()
    e.run_text('
fn sum(n int) int {
    mut acc := 0
    for i in 0 .. n {
        acc += i
    }
    return acc
}

fn main() {
    println(sum(5))
}
') or {
        panic(err)
    }
    assert e.stdout() == '10\n'
}

fn test_eval_registers_top_level_comptime_block_declarations() {
    mut e := create()
    e.run_text('
    $if windows {
    fn gated_message() string {
        return "ok"
    }
} $else $if macos {
    fn gated_message() string {
        return "ok"
    }
} $else {
    fn gated_message() string {
        return "ok"
    }
}

fn main() {
    println(gated_message())
}
    ') or {
        panic(err)
    }
    assert e.stdout() == 'ok\n'
}

fn test_eval_executes_implicit_main_top_level_statements() {
    mut e := create()
    e.run_text('
    mut x := 1
    x += 2
    println(x)
    ') or { panic(err) }
    assert e.stdout() == '3\n'
}

fn test_eval_disabled_if_call_skips_arguments() {
    mut e := create()
    e.run_text('
    __global hit int

@[if trace ?]
fn trace(x int) {}

fn side_effect() int {
    hit = 99
    return 1
}

fn main() {
    trace(side_effect())
    println(int_str(hit))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\n'
}

fn test_eval_labeled_for_in_flow_targets_named_loop() {
    mut e := create()
    e.run_text('
fn main() {
    mut out := ""
    outer: for x in 0 .. 3 {
        for y in 0 .. 3 {
            if x == 1 && y == 0 {
                continue outer
            }
            if x == 2 && y == 1 {
                break outer
            }
            out += "\${x}:\${y};"
        }
    }
    println(out)
}
') or {
        panic(err)
    }
    assert e.stdout() == '0:0;0:1;0:2;2:0;\n'
}

fn test_eval_labeled_c_style_for_flow_targets_named_loop() {
    mut e := create()
    e.run_text('
fn main() {
    mut out := ""
    outer: for x := 0; x < 3; x++ {
        for y := 0; y < 3; y++ {
            if x == 1 && y == 0 {
                continue outer
            }
            if x == 2 && y == 1 {
                break outer
            }
            out += "\${x}:\${y};"
        }
    }
    println(out)
}
') or {
        panic(err)
    }
    assert e.stdout() == '0:0;0:1;0:2;2:0;\n'
}

fn test_eval_if_expr_value() {
    mut e := create()
    e.run_text('
fn main() {
    x := if 3 > 2 {
        41
    } else {
        0
    }
    println(x + 1)
}
') or {
        panic(err)
    }
    assert e.stdout() == '42\n'
}

fn test_eval_char_literal_escapes() {
    mut e := create()
    e.run_text(r"
fn main() {
    println(int_str(`\0`))
    println(int_str(`\\`))
    println(int_str(`\'`))
}
    ") or {
        panic(err)
    }
    assert e.stdout() == '0\n92\n39\n'
}

fn test_eval_match_statement_propagates_return() {
    mut e := create()
    e.run_text('
fn choose(x int) int {
    match x {
        0 {
            return 1
        }
        else {}
    }
    return 2
}

fn main() {
    println(int_str(choose(0)))
    println(int_str(choose(1)))
}
') or {
        panic(err)
    }
    assert e.stdout() == '1\n2\n'
}

fn test_eval_match_condition_propagates_return() {
    mut e := create()
    e.run_text('
fn maybe() ?int {
    return none
}

fn run() int {
    x := 1
    match x {
        maybe() or {
            return 7
        } {}
        else {}
    }
    return 0
}

fn main() {
    println(int_str(run()))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '7\n'
}

fn test_eval_match_branch_shadows_outer_locals() {
    mut e := create()
    e.run_text('
fn stmt_shadow(n int) int {
    x := 1
    match n {
        0 {
            x := 2
            if x != 2 {
                return 99
            }
        }
        else {}
    }
    return x
}

fn value_shadow(n int) int {
    x := 1
    y := match n {
        0 {
            x := 2
            x
        }
        else {
            3
        }
    }
    return x * 10 + y
}

fn main() {
    println(int_str(stmt_shadow(0)))
    println(int_str(stmt_shadow(1)))
    println(int_str(value_shadow(0)))
    println(int_str(value_shadow(1)))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '1\n1\n12\n13\n'
}

fn test_eval_c_style_for_scopes_initializer_and_body() {
    mut e := create()
    e.run_text('
fn main() {
    i := 10
    for i := 0; i < 1; i++ {}
    println(int_str(i))

    x := 1
    for j := 0; j < 2; j++ {
        x := j + 2
        _ = x
    }
    println(int_str(x))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '10\n1\n'
}

fn test_eval_array_append_and_string_interpolation() {
    mut e := create()
    e.run_text('
fn main() {
    mut arr := []int{}
    arr << 7
    arr << 9
    println("\${arr[0]}:\${arr[1]}:\${arr.len}")
}
') or {
        panic(err)
    }
    assert e.stdout() == '7:9:2\n'
}

fn test_eval_array_append_adapts_sum_elements() {
    mut e := create()
    e.run_text('
type Any = int | string

fn main() {
    mut xs := []Any{}
    xs << 1
    xs << "s"
    println(int_str(xs[0]._typ))
    println(int_str(xs[1]._typ))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\n1\n'
}

fn test_eval_array_append_keeps_nested_array_rhs_as_single_element() {
    mut e := create()
    e.run_text('
    fn main() {
    mut nested := [][]int{}
    nested << [1, 2]
    println(int_str(nested.len))
    println(int_str(nested[0].len))
    println(int_str(nested[0][1]))

    mut flat := []int{}
    flat << [3, 4]
    println(int_str(flat.len))
    println(int_str(flat[1]))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '1\n2\n2\n2\n4\n'
}

fn test_eval_array_append_index_target_evaluates_once() {
    mut e := create()
    e.run_text('
    fn next(mut i int) int {
        old := i
        i++
        return old
    }

    fn main() {
        mut xs := [][]int{}
        xs << [1]
        xs << [2]
        mut i := 0
        xs[next(mut i)] << 9
        println(int_str(xs[0].len))
        println(int_str(xs[0][1]))
        println(int_str(xs[1].len))
        println(int_str(i))
    }
        ') or {
        panic(err)
    }
    assert e.stdout() == '2\n9\n1\n1\n'
}

fn test_eval_array_append_rhs_uses_element_enum_type() {
    mut e := create()
    e.run_text('
    enum Color {
        red = 10
    }

    enum Other {
        red = 1
    }

    fn main() {
        mut xs := []Color{}
        xs << .red
        println(xs[0] == Color.red)
    }
        ') or {
        panic(err)
    }
    assert e.stdout() == 'true\n'
}

fn test_eval_value_blocks_execute_array_append_statements() {
    mut e := create()
    e.run_text('
fn maybe() ?int {
    return none
}

fn main() {
    mut xs := []int{}
    n := if true {
        xs << 1
        xs.len
    } else {
        0
    }
    m := maybe() or {
        xs << 2
        xs.len
    }
    println(int_str(n))
    println(int_str(m))
    println(int_str(xs.len))
    println(int_str(xs[0]))
    println(int_str(xs[1]))
}
        ') or {
        panic(err)
    }
    assert e.stdout() == '1\n2\n2\n1\n2\n'
}

fn test_eval_match_value_branches_execute_array_append_statements() {
    mut e := create()
    e.run_text('
fn main() {
    mut xs := []int{}
    n := match 0 {
        0 {
            xs << 1
            xs.len
        }
        else {
            0
        }
    }
    m := match 1 {
        0 {
            0
        }
        else {
            xs << 2
            xs.len
        }
    }
    println(int_str(n))
    println(int_str(m))
    println(int_str(xs.len))
    println(int_str(xs[0]))
    println(int_str(xs[1]))
}
        ') or {
        panic(err)
    }
    assert e.stdout() == '1\n2\n2\n1\n2\n'
}

fn test_eval_or_block_return_propagates_from_array_append_rhs() {
    mut e := create()
    e.run_text('
    fn maybe() ?int {
    return none
}

fn run() int {
    mut xs := []int{}
    xs << (maybe() or {
        return 7
    })
    return xs.len
}

fn main() {
    println(int_str(run()))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '7\n'
}

fn test_eval_for_mut_array_writes_back_elements() {
    mut e := create()
    e.run_text('
struct Item {
mut:
    n int
}

fn main() {
    mut xs := [Item{n: 1}, Item{n: 2}]
    for mut item in xs {
        item.n += 10
    }
    println(int_str(xs[0].n))
    println(int_str(xs[1].n))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '11\n12\n'
}

fn test_eval_for_mut_reuses_resolved_array_container() {
    mut e := create()
    e.run_text('
fn next(mut i int) int {
    old := i
    i++
    return old
}

fn main() {
    mut buckets := [[1], [10]]
    mut i := 0
    for mut x in buckets[next(mut i)] {
        x++
    }
    println(int_str(buckets[0][0]))
    println(int_str(buckets[1][0]))
    println(int_str(i))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '2\n10\n1\n'
}

fn test_eval_array_init_preserves_cap() {
    mut e := create()
    e.run_text('
    fn main() {
    a := []int{cap: 4}
    b := []int{len: 1, cap: 4}
    println(int_str(a.len))
    println(int_str(a.cap))
    println(int_str(b.len))
    println(int_str(b.cap))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\n4\n1\n4\n'
}

fn test_eval_array_init_adapts_sum_elements() {
    mut e := create()
    e.run_text('
type Any = int | string

fn main() {
    xs := []Any{1, "s"}
    ys := []Any{len: 2, init: 1}
    println(int_str(xs[0]._typ))
    println(int_str(xs[1]._typ))
    println(int_str(ys[1]._typ))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\n1\n0\n'
}

fn test_eval_array_init_flow_propagates_return() {
    mut e := create()
    e.run_text('
fn maybe() ?int {
    return none
}

fn run() []int {
    return []int{len: 1, init: maybe() or { return [7] }}
}

fn main() {
    xs := run()
    println(int_str(xs.len))
    println(int_str(xs[0]))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '1\n7\n'
}

fn test_eval_array_init_evaluates_init_for_each_index() {
    mut e := create()
    e.run_text('
fn bump(mut calls int) int {
    calls++
    return calls
}

fn main() {
    mut calls := 0
    xs := []int{len: 3, init: index}
    ys := []int{len: 3, init: index + bump(mut calls)}
    fixed := [3]int{init: index}
    println(int_str(xs[0]))
    println(int_str(xs[2]))
    println(int_str(ys[0]))
    println(int_str(ys[2]))
    println(int_str(calls))
    println(int_str(fixed[2]))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\n2\n1\n5\n3\n2\n'
}

fn test_eval_fixed_array_init_uses_declared_len() {
    mut e := create()
    e.run_text('
fn main() {
    a := [3]int{}
    b := [3]int{init: 5}
    nested := [2][2]int{}
    dynamic := [][2]int{}
    println(int_str(a.len))
    println(int_str(a[2]))
    println(int_str(b.len))
    println(int_str(b[1]))
    println(int_str(nested[1][1]))
    println(int_str(dynamic.len))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '3\n0\n3\n5\n0\n0\n'
}

fn test_eval_fixed_array_init_resolves_const_len() {
    mut e := create()
    e.run_text('
const n = 3

struct Box {
    xs [n]int
}

fn main() {
    a := [n]int{}
    b := [n]int{init: index}
    box := Box{}
    println(int_str(a.len))
    println(int_str(a[2]))
    println(int_str(b.len))
    println(int_str(b[2]))
    println(int_str(box.xs.len))
    println(int_str(box.xs[2]))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '3\n0\n3\n2\n3\n0\n'
}

fn test_eval_right_shift_compound_assignment() {
    mut e := create()
    e.run_text('
fn main() {
    mut x := 8
    x >>= 1
    println(int_str(x))
}
') or { panic(err) }
    assert e.stdout() == '4\n'
}

fn test_eval_unsigned_right_shift_and_compound_assignment() {
    mut e := create()
    e.run_text('
fn main() {
    println(int_str(i64(-5) >>> 1))
    mut x := i64(-5)
    x >>>= 1
    println(int_str(x))
}
') or {
        panic(err)
    }
    assert e.stdout() == '9223372036854775805\n9223372036854775805\n'
}

fn test_eval_compound_index_target_evaluates_once() {
    mut e := create()
    e.run_text('
fn next(mut i int) int {
    old := i
    i++
    return old
}

fn main() {
    mut xs := [1, 2]
    mut i := 0
    xs[next(mut i)] += 10
    println(int_str(xs[0]))
    println(int_str(xs[1]))
    println(int_str(i))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '11\n2\n1\n'
}

fn test_eval_selector_index_receiver_evaluates_once_on_write() {
    mut e := create()
    e.run_text('
struct Item {
mut:
    x int
}

fn next(mut i int) int {
    old := i
    i++
    return old
}

fn main() {
    mut xs := [Item{x: 1}, Item{x: 2}]
    mut i := 0
    xs[next(mut i)].x = 5
    println(int_str(xs[0].x))
    println(int_str(xs[1].x))
    println(int_str(i))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '5\n2\n1\n'
}

fn test_eval_struct_method_and_map_update() {
    mut e := create()
    e.run_text("
struct Point {
    x int
    y int
}

fn (p Point) sum() int {
    return p.x + p.y
}

fn main() {
    p := Point{x: 2, y: 5}
    mut m := map[string]int{}
    m['a'] = p.sum()
    m['b'] += 3
    println(int_str(m['a'] + m['b']))
}
") or {
        panic(err)
    }
    assert e.stdout() == '10\n'
}

fn test_eval_static_method_dispatches_from_type_value() {
    mut e := create()
    e.run_text('
struct Foo {
    n int
}

fn Foo.new(n int) Foo {
    return Foo{n: n}
}

fn main() {
    foo := Foo.new(7)
    println(int_str(foo.n))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '7\n'
}

fn test_eval_overloaded_plus_operator_dispatches_method() {
    mut e := create()
    e.run_text('
struct Number {
    value int
}

fn (a Number) + (b Number) Number {
    return Number{value: a.value + b.value}
}

fn main() {
    c := Number{value: 2} + Number{value: 5}
    println(int_str(c.value))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '7\n'
}

fn test_eval_alias_receiver_method_dispatches_by_static_type() {
    mut e := create()
    e.run_text('
type UserId = int

fn (id UserId) next() int {
    return int(id) + 1
}

fn main() {
    id := UserId(1)
    println(int_str(id.next()))
    println(int_str(UserId(2).next()))
}
') or {
        panic(err)
    }
    assert e.stdout() == '2\n3\n'
}

fn test_eval_typeof_name_selector_returns_type_name() {
    mut e := create()
    e.run_text('
fn main() {
    println(typeof(1).name)
    println(typeof("x").name)
}
    ') or {
        panic(err)
    }
    assert e.stdout() == 'int\nstring\n'
}

fn test_eval_map_delete_mutates_receiver() {
    mut e := create()
    e.run_text("
    fn main() {
    mut m := map[string]int{}
    m['a'] = 7
    m.delete('a')
    println(int_str(m.len))
    println('a' in m)
    println(int_str(m['a']))
}
") or {
        panic(err)
    }
    assert e.stdout() == '0\nfalse\n0\n'
}

fn test_eval_map_delete_index_receiver_evaluates_once() {
    mut e := create()
    e.run_text("
    fn next(mut i int) int {
        old := i
        i++
        return old
    }

    fn main() {
        mut maps := []map[string]int{}
        maps << map[string]int{'a': 1}
        maps << map[string]int{'a': 2}
        mut i := 0
        maps[next(mut i)].delete('a')
        println('a' in maps[0])
        println('a' in maps[1])
        println(int_str(i))
    }
    ") or {
        panic(err)
    }
    assert e.stdout() == 'false\ntrue\n1\n'
}

fn test_eval_map_literal_adapts_sum_values() {
    mut e := create()
    e.run_text('
    type Any = int | string

fn main() {
    m := map[string]Any{"a": 1, "b": "s"}
    println(int_str(m["a"]._typ))
    println(int_str(m["b"]._typ))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\n1\n'
}

fn test_eval_map_literal_keys_use_declared_enum_type() {
    mut e := create()
    e.run_text('
enum Color {
    red
}

enum Other {
    red = 10
}

fn main() {
    m := map[Color]int{.red: 7}
    println(int_str(m[Color.red]))
    println(int_str(m[.red] or { 0 }))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '7\n7\n'
}

fn test_eval_container_methods_use_declared_enum_arg_type() {
    mut e := create()
    e.run_text('
enum Color {
    red
    blue
}

enum Other {
    red = 10
}

fn main() {
    mut m := map[Color]int{.red: 1}
    m.delete(.red)
    println(int_str(m.len))
    xs := [Color.red, Color.blue]
    println(xs.contains(.red))
    println(int_str(xs.index(.red)))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\ntrue\n0\n'
}

fn test_eval_map_literal_value_flow_propagates_return() {
    mut e := create()
    e.run_text('
fn maybe() ?int {
    return none
}

fn run() map[string]int {
    return {
        "a": maybe() or {
            return {
                "b": 7
            }
        }
    }
}

fn main() {
    m := run()
    println(int_str(m["b"]))
    println(int_str(m["a"]))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '7\n0\n'
}

fn test_eval_map_lookup_adapts_sum_keys() {
    mut e := create()
    e.run_text('
type Any = int | string

fn main() {
    m := map[Any]int{1: 2, "s": 3}
    println(int_str(m[1]))
    println(int_str(m["s"]))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '2\n3\n'
}

fn test_eval_indexed_writes_adapt_sum_values() {
    mut e := create()
    e.run_text('
type Any = int | string

fn main() {
    mut xs := []Any{len: 2}
    xs[0] = 1
    xs[1] = "s"
    println(int_str(xs[0]._typ))
    println(int_str(xs[1]._typ))

    mut m := map[string]Any{}
    m["a"] = 1
    m["b"] = "s"
    println(int_str(m["a"]._typ))
    println(int_str(m["b"]._typ))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\n1\n0\n1\n'
}

fn test_eval_index_assignment_lhs_index_propagates_return() {
    mut e := create()
    e.run_text('
fn idx() ?int {
    return none
}

fn run() int {
    mut xs := [0]
    xs[idx() or {
        return 7
    }] = 1
    return xs[0]
}

fn main() {
    println(int_str(run()))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '7\n'
}

fn test_eval_postfix_index_target_evaluates_once() {
    mut e := create()
    e.run_text('
fn next(mut i int) int {
    old := i
    i++
    return old
}

fn main() {
    mut xs := [1, 2]
    mut i := 0
    old := xs[next(mut i)]++
    println(int_str(old))
    println(int_str(xs[0]))
    println(int_str(xs[1]))
    println(int_str(i))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '1\n2\n2\n1\n'
}

fn test_eval_postfix_index_target_propagates_flow() {
    mut e := create()
    e.run_text('
fn idx() ?int {
    return none
}

fn run() int {
    mut xs := [0]
    xs[idx() or {
        return 7
    }]++
    return xs[0]
}

fn main() {
    println(int_str(run()))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '7\n'
}

fn test_eval_array_literal_preserves_element_type_for_sum_checks() {
    mut e := create()
    e.run_text('
type Any = []int | string

fn main() {
    x := Any([1, 2])
    println(x is []int)
}
    ') or {
        panic(err)
    }
    assert e.stdout() == 'true\n'
}

fn test_eval_shorthand_map_literal_infers_key_value_types() {
    mut e := create()
    e.run_text('
fn main() {
    m := {"a": 1}
    println(int_str(m["a"]))
    println(int_str(m["missing"]))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '1\n0\n'
}

fn test_eval_typed_map_target_adapts_entries() {
    mut e := create()
    e.run_text('
type Any = int | string

struct S {
    m map[string]Any
}

fn main() {
    s := S{
        m: {
            "a": 1
            "b": "s"
        }
    }
    println(int_str(s.m["a"]._typ))
    println(int_str(s.m["b"]._typ))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\n1\n'
}

fn test_eval_mut_receiver_method_updates_original() {
    mut e := create()
    e.run_text('
struct Point {
mut:
    x int
}

fn (mut p Point) inc() int {
    p.x += 1
    return p.x
}

fn main() {
    mut p := Point{x: 1}
    println(int_str(p.inc()))
    println(int_str(p.x))
}
') or {
        panic(err)
    }
    assert e.stdout() == '2\n2\n'
}

fn test_eval_mut_function_arg_updates_original() {
    mut e := create()
    e.run_text('
fn inc(mut x int) {
    x++
}

fn main() {
    mut a := 1
    inc(mut a)
    println(int_str(a))
}
') or {
        panic(err)
    }
    assert e.stdout() == '2\n'
}

fn test_eval_mut_index_argument_writes_back_once() {
    mut e := create()
    e.run_text('
fn next(mut i int) int {
    old := i
    i++
    return old
}

fn inc(mut x int) {
    x++
}

fn main() {
    mut xs := [1, 2]
    mut i := 0
    inc(mut xs[next(mut i)])
    println(int_str(xs[0]))
    println(int_str(xs[1]))
    println(int_str(i))
}
') or {
        panic(err)
    }
    assert e.stdout() == '2\n2\n1\n'
}

fn test_eval_mut_function_literal_arg_updates_original() {
    mut e := create()
    e.run_text('
fn main() {
    f := fn (mut x int) {
        x++
    }
    mut a := 1
    f(mut a)
    println(int_str(a))
}
') or {
        panic(err)
    }
    assert e.stdout() == '2\n'
}

fn test_eval_function_literal_arg_adapts_to_sum_param() {
    mut e := create()
    e.run_text('
type Any = int | string

fn main() {
    f := fn (x Any) {
        println(int_str(x._typ))
    }
    f(1)
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\n'
}

fn test_eval_variadic_arguments_pack_into_array() {
    mut e := create()
    e.run_text('
fn count(xs ...int) int {
    return xs.len
}

fn sum(seed int, xs ...int) int {
    mut total := seed
    for x in xs {
        total += x
    }
    return total
}

fn main() {
    println(int_str(count()))
    println(int_str(count(1, 2)))
    println(int_str(sum(10, 1, 2, 3)))
    f := fn (xs ...int) int {
        return xs.len
    }
    println(int_str(f(4, 5, 6)))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\n2\n16\n3\n'
}

fn test_eval_function_literal_captures_escaping_scope() {
    mut e := create()
    e.run_text('
fn make() fn () int {
    x := 7
    return fn [x] () int {
        return x
    }
}

fn main() {
    f := make()
    println(int_str(f()))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '7\n'
}

fn test_eval_mut_function_literal_capture_persists_between_calls() {
    mut e := create()
    e.run_text('
fn new_counter() fn () int {
    mut i := 0
    return fn [mut i] () int {
        i++
        return i
    }
}

fn main() {
    counter := new_counter()
    println(int_str(counter()))
    println(int_str(counter()))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '1\n2\n'
}

fn test_eval_mut_closure_param_preserves_capture_state() {
    mut e := create()
    e.run_text('
fn new_counter() fn () int {
    mut i := 0
    return fn [mut i] () int {
        i++
        return i
    }
}

fn use(f fn () int) {
    println(int_str(f()))
    println(int_str(f()))
}

fn main() {
    counter := new_counter()
    use(counter)
    println(int_str(counter()))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '1\n2\n3\n'
}

fn test_eval_function_valued_selector_call_updates_captures() {
    mut e := create()
    e.run_text('
struct S {
    f fn () int
}

fn new_counter() fn () int {
    mut i := 0
    return fn [mut i] () int {
        i++
        return i
    }
}

fn main() {
    mut s := S{
        f: new_counter()
    }
    println(int_str(s.f()))
    println(int_str(s.f()))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '1\n2\n'
}

fn test_eval_mut_method_arg_updates_original() {
    mut e := create()
    e.run_text('
struct S {}

fn (s S) inc(mut x int) {
    x++
}

fn main() {
    s := S{}
    mut a := 1
    s.inc(mut a)
    println(int_str(a))
}
') or {
        panic(err)
    }
    assert e.stdout() == '2\n'
}

fn test_eval_multi_return_assignment_spreads_tuple() {
    mut e := create()
    e.run_text("
fn pair() (int, string) {
    return 2, 'ok'
}

fn main() {
    a, b := pair()
    println(int_str(a))
    println(b)
}
") or {
        panic(err)
    }
    assert e.stdout() == '2\nok\n'
}

fn test_eval_multi_return_assignment_spreads_three_value_tuple() {
    mut e := create()
    e.run_text("
fn triple() (int, string, int) {
    return 1, 'two', 3
}

fn main() {
    a, b, c := triple()
    println(int_str(a))
    println(b)
    println(int_str(c))
}
") or {
        panic(err)
    }
    assert e.stdout() == '1\ntwo\n3\n'
}

fn test_eval_multi_return_adapts_items_to_declared_types() {
    mut e := create()
    e.run_text('
type Any = int | string

fn pair() (Any, Any) {
    return 1, "s"
}

fn main() {
    a, b := pair()
    println(int_str(a._typ))
    println(int_str(b._typ))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\n1\n'
}

fn test_eval_imported_return_adapts_in_callee_module() {
    dir := os.join_path(os.temp_dir(), 'v3_eval_import_return_${os.getpid()}')
    os.rmdir_all(dir) or {}
    os.mkdir_all(dir) or { panic(err) }
    defer {
        os.rmdir_all(dir) or {}
    }
    main_file := os.join_path(dir, 'main.v')
    mod_file := os.join_path(dir, 'm.v')
    os.write_file(mod_file, '
module m

pub type Any = int | string

pub fn make() Any {
    return 1
}
    ') or {
        panic(err)
    }
    os.write_file(main_file, '
module main

import m

fn main() {
    x := m.make()
    println(int_str(x._typ))
    if x is int {
        println("int")
    }
}
    ') or {
        panic(err)
    }
    mut e := create()
    mut p := parser.Parser.new(&e.prefs)
    p.parse_files([main_file, mod_file])
    e.run_files(p.a) or { panic(err) }
    assert e.stdout() == '0\nint\n'
}

fn test_eval_imported_array_return_qualifies_element_type() {
    dir := os.join_path(os.temp_dir(), 'v3_eval_import_array_return_${os.getpid()}')
    os.rmdir_all(dir) or {}
    os.mkdir_all(dir) or { panic(err) }
    defer {
        os.rmdir_all(dir) or {}
    }
    main_file := os.join_path(dir, 'main.v')
    mod_file := os.join_path(dir, 'm.v')
    os.write_file(mod_file, '
module m

pub struct Item {}

pub fn items() []Item {
    return [Item{}]
}
    ') or {
        panic(err)
    }
    os.write_file(main_file, '
module main

import m

fn main() {
    mut xs := m.items()
    xs << [m.Item{}, m.Item{}]
    println(int_str(xs.len))
}
    ') or {
        panic(err)
    }
    mut e := create()
    mut p := parser.Parser.new(&e.prefs)
    p.parse_files([main_file, mod_file])
    e.run_files(p.a) or { panic(err) }
    assert e.stdout() == '3\n'
}

fn test_eval_imported_struct_field_default_adapts_in_declaring_module() {
    dir := os.join_path(os.temp_dir(), 'v3_eval_import_field_default_${os.getpid()}')
    os.rmdir_all(dir) or {}
    os.mkdir_all(dir) or { panic(err) }
    defer {
        os.rmdir_all(dir) or {}
    }
    main_file := os.join_path(dir, 'main.v')
    mod_file := os.join_path(dir, 'm.v')
    os.write_file(mod_file, '
module m

pub struct A {}

pub type Any = A | string

pub struct Box {
pub:
    x Any = A{}
}
    ') or {
        panic(err)
    }
    os.write_file(main_file, '
module main

import m

fn main() {
    box := m.Box{}
    println(int_str(box.x._typ))
    if box.x is m.A {
        println("a")
    }
}
    ') or {
        panic(err)
    }
    mut e := create()
    mut p := parser.Parser.new(&e.prefs)
    p.parse_files([main_file, mod_file])
    e.run_files(p.a) or { panic(err) }
    assert e.stdout() == '0\na\n'
}

fn test_eval_imported_struct_field_container_type_uses_declaring_module() {
    dir := os.join_path(os.temp_dir(), 'v3_eval_import_field_container_${os.getpid()}')
    os.rmdir_all(dir) or {}
    os.mkdir_all(dir) or { panic(err) }
    defer {
        os.rmdir_all(dir) or {}
    }
    main_file := os.join_path(dir, 'main.v')
    mod_file := os.join_path(dir, 'm.v')
    os.write_file(mod_file, '
module m

pub struct Item {}

pub struct Box {
pub mut:
    xs []Item
}
    ') or {
        panic(err)
    }
    os.write_file(main_file, '
module main

import m

fn main() {
    box := m.Box{xs: [m.Item{}]}
    mut xs := box.xs
    xs << [m.Item{}, m.Item{}]
    println(int_str(xs.len))
}
    ') or {
        panic(err)
    }
    mut e := create()
    mut p := parser.Parser.new(&e.prefs)
    p.parse_files([main_file, mod_file])
    e.run_files(p.a) or { panic(err) }
    assert e.stdout() == '3\n'
}

fn test_eval_value_block_preserves_multi_return_values() {
    mut e := create()
    e.run_text("
fn choose(ok bool) (int, string) {
    return if ok { 1, 'a' } else { 2, 'b' }
}

fn main() {
    a, b := choose(true)
    c, d := choose(false)
    println('\${a}:\${b}:\${c}:\${d}')
}
") or {
        panic(err)
    }
    assert e.stdout() == '1:a:2:b\n'
}

fn test_eval_value_block_uses_last_sequential_expression_value() {
    mut e := create()
    e.run_text('
    fn trace() int {
        return 1
    }

    fn choose(ok bool) int {
        return if ok {
            trace()
        2
    } else {
        3
    }
}

fn main() {
    println(int_str(choose(true)))
    println(int_str(choose(false)))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '2\n3\n'
}

fn test_eval_multi_assign_preserves_rhs_values() {
    mut e := create()
    e.run_text('
fn main() {
    mut a := 1
    mut b := 2
    a, b = b, a
    println(int_str(a))
    println(int_str(b))
}
') or {
        panic(err)
    }
    assert e.stdout() == '2\n1\n'
}

fn test_eval_multi_assign_propagates_rhs_flow() {
    mut e := create()
    e.run_text('
fn maybe_pair() ?(int, int) {
    return none
}

fn run() int {
    a, b := maybe_pair() or {
        return 7
    }
    return a + b
}

fn main() {
    println(int_str(run()))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '7\n'
}

fn test_eval_struct_equality_compares_fields() {
    mut e := create()
    e.run_text('
struct Point {
    x int
}

fn main() {
    a := Point{x: 1}
    b := Point{x: 2}
    c := Point{x: 1}
    println(a == b)
    println(a == c)
}
') or {
        panic(err)
    }
    assert e.stdout() == 'false\ntrue\n'
}

fn test_eval_scopes_enum_constants_by_enum_type() {
    mut e := create()
    e.run_text('
enum A {
    x
}

enum B {
    x = 10
}

fn main() {
    println(int_str(A.x))
    println(int_str(B.x))
}
') or {
        panic(err)
    }
    assert e.stdout() == '0\n10\n'
}

fn test_eval_enum_selector_preserves_sum_variant_type() {
    mut e := create()
    e.run_text('
enum Test {
    abc
}

type SumTest = Test | u8

fn main() {
    b := SumTest(Test.abc)
    println(b is Test)
    println(b is u8)
}
    ') or {
        panic(err)
    }
    assert e.stdout() == 'true\nfalse\n'
}

fn test_eval_match_shorthand_enum_uses_target_enum_type() {
    mut e := create()
    e.run_text('
enum A {
    x
}

enum B {
    x = 10
}

fn main() {
    match A.x {
        .x {
            println("a")
        }
        else {
            println("bad")
        }
    }
}
') or {
        panic(err)
    }
    assert e.stdout() == 'a\n'
}

fn test_eval_match_shorthand_enum_uses_tracked_var_type() {
    mut e := create()
    e.run_text('
enum A {
    x
}

enum B {
    x = 10
}

fn main() {
    a := A.x
    match a {
        .x {
            println("a")
        }
        else {
            println("bad")
        }
    }
}
') or {
        panic(err)
    }
    assert e.stdout() == 'a\n'
}

fn test_eval_enum_zero_values_use_first_field() {
    mut e := create()
    e.run_text('
    enum Color {
    red
    blue
}

struct S {
    c Color
}

__global g Color

fn main() {
    s := S{}
    arr := [2]Color{}
    m := map[string]Color{}
    println(s.c == Color.red)
    println(g == Color.red)
    println(arr[0] == Color.red)
    println(m["missing"] == Color.red)
}
    ') or {
        panic(err)
    }
    assert e.stdout() == 'true\ntrue\ntrue\ntrue\n'
}

fn test_eval_enum_cast_preserves_enum_identity() {
    mut e := create()
    e.run_text('
    enum Color {
        red
        blue
    }

    type Any = Color | int

    fn main() {
        c := Color(1)
        x := Any(Color(1))
        println(c == Color.blue)
        println(c)
        println(x is Color)
    }
        ') or {
        panic(err)
    }
    assert e.stdout() == 'true\nblue\ntrue\n'
}

fn test_eval_global_assignment_uses_declared_type() {
    mut e := create()
    e.run_text('
    enum State {
    idle
    busy
}

__global state State

fn main() {
    state = .busy
    println(state)
}
    ') or {
        panic(err)
    }
    assert e.stdout() == 'busy\n'
}

fn test_eval_enum_shorthand_return_preserves_enum_type() {
    mut e := create()
    e.run_text('
enum Color {
    red
    blue
}

type Any = Color | int

fn color() Color {
    return .red
}

fn main() {
    c := color()
    x := Any(c)
    println(c == Color.red)
    println(x is Color)
    println(int_str(x._typ))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == 'true\ntrue\n0\n'
}

fn test_eval_enum_shorthand_return_uses_expected_type_in_value_branches() {
    mut e := create()
    e.run_text('
enum Color {
    red = 10
    blue = 20
}

enum Other {
    red = 1
    blue = 2
}

fn pick_if(b bool) Color {
    return if b {
        .red
    } else {
        .blue
    }
}

fn pick_match(n int) Color {
    return match n {
        0 {
            .red
        }
        else {
            .blue
        }
    }
}

fn main() {
    println(pick_if(true) == Color.red)
    println(pick_if(false) == Color.blue)
    println(pick_match(0) == Color.red)
    println(pick_match(1) == Color.blue)
}
    ') or {
        panic(err)
    }
    assert e.stdout() == 'true\ntrue\ntrue\ntrue\n'
}

fn test_eval_enum_shorthand_uses_typed_call_and_struct_contexts() {
    mut e := create()
    e.run_text('
enum A {
    x
}

enum B {
    x = 10
}

struct S {
    c A
}

fn take_a(a A) int {
    return int(a)
}

fn main() {
    s := S{c: .x}
    println(int_str(take_a(.x)))
    println(int_str(s.c))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\n0\n'
}

fn test_eval_imported_function_param_hints_are_qualified() {
    dir := os.join_path(os.temp_dir(), 'v3_eval_import_param_hint_${os.getpid()}')
    os.rmdir_all(dir) or {}
    os.mkdir_all(dir) or { panic(err) }
    defer {
        os.rmdir_all(dir) or {}
    }
    main_file := os.join_path(dir, 'main.v')
    mod_file := os.join_path(dir, 'm.v')
    os.write_file(mod_file, '
module m

pub enum Color {
    red
    blue
}

pub fn take(c Color) string {
    if c == Color.red {
        return "m-red"
    }
    return "wrong"
}
    ') or {
        panic(err)
    }
    os.write_file(main_file, '
module main

import m

enum Other {
    red = 10
}

fn main() {
    println(m.take(.red))
}
    ') or {
        panic(err)
    }
    mut e := create()
    mut p := parser.Parser.new(&e.prefs)
    p.parse_files([main_file, mod_file])
    e.run_files(p.a) or { panic(err) }
    assert e.stdout() == 'm-red\n'
}

fn test_eval_imported_fn_value_param_hints_are_qualified() {
    dir := os.join_path(os.temp_dir(), 'v3_eval_import_fn_value_hint_${os.getpid()}')
    os.rmdir_all(dir) or {}
    os.mkdir_all(dir) or { panic(err) }
    defer {
        os.rmdir_all(dir) or {}
    }
    main_file := os.join_path(dir, 'main.v')
    mod_file := os.join_path(dir, 'm.v')
    os.write_file(mod_file, '
module m

pub enum Color {
    red
    blue
}

pub fn make_taker() fn (Color) string {
    return fn (c Color) string {
        if c == Color.red {
            return "m-red"
        }
        return "wrong"
    }
}
    ') or {
        panic(err)
    }
    os.write_file(main_file, '
module main

import m

enum Other {
    red = 10
}

fn main() {
    f := m.make_taker()
    println(f(.red))
}
    ') or {
        panic(err)
    }
    mut e := create()
    mut p := parser.Parser.new(&e.prefs)
    p.parse_files([main_file, mod_file])
    e.run_files(p.a) or { panic(err) }
    assert e.stdout() == 'm-red\n'
}

fn test_eval_match_range_patterns_are_inclusive() {
    mut e := create()
    e.run_text('
fn classify_stmt(n int) string {
    mut out := ""
    match n {
        1...3 {
            out = "range"
        }
        else {
            out = "other"
        }
    }
    return out
}

fn classify_expr(n int) string {
    return match n {
        1...3 {
            "range"
        }
        else {
            "other"
        }
    }
}

fn main() {
    println(classify_stmt(3))
    println(classify_expr(1))
    println(classify_expr(4))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == 'range\nrange\nother\n'
}

fn test_eval_match_primitive_sum_branches_are_type_patterns() {
    mut e := create()
    e.run_text('
    type Any = int | string

fn classify(x Any) string {
    return match x {
        int {
            "int"
        }
        string {
            "string"
        }
        else {
            "other"
        }
    }
}

fn main() {
    println(classify(1))
    println(classify("s"))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == 'int\nstring\n'
}

fn test_eval_match_value_pattern_is_not_type_pattern() {
    mut e := create()
    e.run_text('
    type Any = int | string

    fn classify(x Any) string {
        return match x {
            "int" {
                "literal"
            }
            int {
                "type"
            }
            else {
                "other"
            }
        }
    }

    fn main() {
        println(classify(1))
    }
        ') or {
        panic(err)
    }
    assert e.stdout() == 'type\n'
}

fn test_eval_sum_smartcasts_bind_branch_payloads() {
    mut e := create()
    e.run_text('
    type Any = int | string

fn if_cast(x Any) int {
    if x is int {
        return x + 1
    }
    return 0
}

fn match_cast(x Any) int {
    return match x {
        int {
            x + 2
        }
        else {
            0
        }
    }
}

fn main() {
    println(int_str(if_cast(1)))
    println(int_str(if_cast("s")))
    println(int_str(match_cast(1)))
    println(int_str(match_cast("s")))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '2\n0\n3\n0\n'
}

fn test_eval_logical_and_rhs_uses_is_smartcast() {
    mut e := create()
    e.run_text('
type Any = int | string

fn positive(x Any) bool {
    return x is int && x > 0
}

fn main() {
    println(positive(2))
    println(positive(-1))
    println(positive("s"))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == 'true\nfalse\nfalse\n'
}

fn test_eval_calls_function_value_from_identifier() {
    mut e := create()
    e.run_text('
fn main() {
    f := fn () int {
        return 1
    }
    println(int_str(f()))
}
') or {
        panic(err)
    }
    assert e.stdout() == '1\n'
}

fn test_eval_prefix_minus_preserves_float() {
    mut e := create()
    e.run_text('
fn main() {
    x := 1.5
    println(-1.5)
    println(-x)
}
    ') or { panic(err) }
    assert e.stdout() == '-1.5\n-1.5\n'
}

fn test_eval_mixed_numeric_equality_compares_as_float() {
    mut e := create()
    e.run_text('
fn main() {
    println(1 == 1.5)
    println(1.5 == 1)
    println(1 == 1.0)
    println(1.0 == 1)
    println(1 != 1.5)
}
') or {
        panic(err)
    }
    assert e.stdout() == 'false\nfalse\ntrue\ntrue\ntrue\n'
}

fn test_eval_number_literals_strip_separators() {
    mut e := create()
    e.run_text('
fn main() {
    println(int_str(1_234))
    println(int_str(0x1_f))
    println(1_234.5 == 1234.5)
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '1234\n31\ntrue\n'
}

fn test_eval_sum_numeric_as_cast_unwraps_payload() {
    mut e := create()
    e.run_text('
type Any = int | string

fn main() {
    x := Any(7)
    println(int_str(x as int))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '7\n'
}

fn test_eval_alias_field_zero_value_uses_underlying_type() {
    mut e := create()
    e.run_text('
type UserId = int

struct S {
    id UserId
}

fn main() {
    println(int_str(S{}.id))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\n'
}

fn test_eval_alias_to_sum_param_adapts_argument() {
    mut e := create()
    e.run_text('
type Any = int | string
type Alias = Any

fn variant(x Alias) int {
    return x._typ
}

fn main() {
    println(int_str(variant(1)))
    println(int_str(variant("s")))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\n1\n'
}

fn test_eval_struct_field_writes_adapt_sum_values() {
    mut e := create()
    e.run_text('
type Any = int | string

struct S {
mut:
    a Any
}

fn main() {
    mut s := S{}
    s.a = 1
    println(int_str(s.a._typ))
    s.a = "s"
    println(int_str(s.a._typ))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\n1\n'
}

fn test_eval_struct_init_fields_adapt_sum_values() {
    mut e := create()
    e.run_text('
type Any = int | string

struct S {
    a Any
    b Any
}

fn main() {
    s := S{a: 1, b: "s"}
    println(int_str(s.a._typ))
    println(int_str(s.b._typ))
    t := S{
        ...s
        a: "x"
    }
    println(int_str(t.a._typ))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\n1\n1\n'
}

fn test_eval_defer_runs_before_function_return() {
    mut e := create()
    e.run_text('
fn run() int {
    defer {
        println("first")
    }
    defer {
        println("second")
    }
    println("body")
    return 7
}

fn main() {
    println(int_str(run()))
}
') or {
        panic(err)
    }
    assert e.stdout() == 'body\nsecond\nfirst\n7\n'
}

fn test_eval_scoped_defers_run_at_scope_exit() {
    mut e := create()
    e.run_text('
fn main() {
    mut out := ""
    if true {
        defer {
            out += "d"
        }
        out += "b"
    }
    out += "a"
    for i in 0 .. 2 {
        defer {
            out += int_str(i)
        }
        out += "i"
    }
    println(out)
}
    ') or {
        panic(err)
    }
    assert e.stdout() == 'bdai0i1\n'
}

fn test_eval_defer_fn_runs_at_function_exit() {
    mut e := create()
    e.run_text('
__global hit int

fn run() {
    for _ in 0 .. 2 {
        defer(fn) {
            hit += 100
        }
        println(int_str(hit))
        hit++
    }
    println(int_str(hit))
}

fn main() {
    run()
    println(int_str(hit))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\n1\n2\n202\n'
}

fn test_eval_or_block_return_propagates() {
    mut e := create()
    e.run_text('
fn maybe() ?int {
    return none
}

fn run() int {
    _ := maybe() or {
        return 1
    }
    return 2
}

fn main() {
    println(int_str(run()))
}
') or {
        panic(err)
    }
    assert e.stdout() == '1\n'
}

fn test_eval_optional_bool_return_wraps_false_payload() {
    mut e := create()
    e.run_text('
fn maybe() ?bool {
    return false
}

fn run_or() bool {
    return maybe() or {
        return true
    }
}

fn run_guard() string {
    if v := maybe() {
        if v {
            return "true"
        }
        return "false"
    }
    return "none"
}

fn main() {
    println(run_or())
    println(run_guard())
}
    ') or {
        panic(err)
    }
    assert e.stdout() == 'false\nfalse\n'
}

fn test_eval_optional_if_guard_binds_payload_type() {
    mut e := create()
    e.run_text('
fn maybe() ?int {
    return 41
}

fn absent() ?int {
    return none
}

fn main() {
    if x := maybe() {
        println(int_str(x + 1))
    } else {
        println("missing")
    }
    if x := absent() {
        println(int_str(x))
    } else {
        println("absent")
    }
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '42\nabsent\n'
}

fn test_eval_optional_sum_return_adapts_payload_before_wrapping() {
    mut e := create()
    e.run_text('
type Any = int | string

fn maybe() ?Any {
    return 1
}

fn main() {
    x := maybe() or {
        return
    }
    println(int_str(x._typ))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\n'
}

fn test_eval_or_block_return_propagates_from_call_argument() {
    mut e := create()
    e.run_text('
fn maybe() ?int {
    return none
}

fn run() int {
    println(int_str(maybe() or {
        return 1
    }))
    return 2
}

fn main() {
    println(int_str(run()))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '1\n'
}

fn test_eval_or_block_return_propagates_from_nested_infix() {
    mut e := create()
    e.run_text('
fn maybe() ?int {
    return none
}

fn run() int {
    x := (maybe() or {
        return 12
    }) + 1
    return x
}

fn main() {
    println(int_str(run()))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '12\n'
}

fn test_eval_or_block_return_propagates_from_selector_receiver() {
    mut e := create()
    e.run_text('
fn maybe() ?string {
    return none
}

fn run() string {
    n := (maybe() or {
        return "early"
    }).len
    return int_str(n)
}

fn main() {
    println(run())
}
    ') or {
        panic(err)
    }
    assert e.stdout() == 'early\n'
}

fn test_eval_or_block_return_propagates_from_method_receiver() {
    mut e := create()
    e.run_text('
fn maybe_arr() ?[]int {
    return none
}

fn run() int {
    x := (maybe_arr() or {
        return 12
    }).first()
    return x
}

fn main() {
    println(int_str(run()))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '12\n'
}

fn test_eval_or_block_return_propagates_from_outer_or_left_operand() {
    mut e := create()
    e.run_text('
fn maybe() ?int {
    return none
}

fn wrap(x int) ?int {
    return x
}

fn run() int {
    _ := wrap(maybe() or {
        return 1
    }) or {
        return 2
    }
    return 3
}

fn main() {
    println(int_str(run()))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '1\n'
}

fn test_eval_or_block_return_propagates_from_match_subject() {
    mut e := create()
    e.run_text('
fn maybe() ?int {
    return none
}

fn run() int {
    match (maybe() or {
        return 7
    }) {
        else {}
    }
    return 0
}

fn main() {
    println(int_str(run()))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '7\n'
}

fn test_eval_map_index_or_uses_lookup_presence() {
    mut e := create()
    e.run_text('
fn main() {
    mut m := map[string]int{}
    m["present"] = 0
    println(int_str(m["present"] or { 7 }))
    println(int_str(m["missing"] or { 7 }))

    mut s := map[string]string{}
    s["empty"] = ""
    println(s["empty"] or { "fallback" })
    println(s["missing"] or { "fallback" })
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\n7\n\nfallback\n'
}

fn test_eval_map_index_if_guard_uses_lookup_presence() {
    mut e := create()
    e.run_text('
fn main() {
    mut m := map[string]int{}
    m["present"] = 0
    if v := m["present"] {
        println(int_str(v))
    } else {
        println("missing-present")
    }
    if v := m["missing"] {
        println(int_str(v))
    } else {
        println("missing")
    }
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '0\nmissing\n'
}

fn test_eval_postfix_option_propagates_failure() {
    mut e := create()
    e.run_text('
fn maybe() ?int {
    return none
}

fn run() ?int {
    maybe()?
    println("after")
    return 1
}

fn main() {
    run() or {
        println("none")
        return
    }
}
    ') or {
        panic(err)
    }
    assert e.stdout() == 'none\n'
}

fn test_eval_or_block_binds_err() {
    mut e := create()
    e.run_text('
fn maybe() ?int {
    return none
}

fn main() {
    maybe() or {
        _ := err
        println("handled")
        return
    }
}
    ') or {
        panic(err)
    }
    assert e.stdout() == 'handled\n'
}

fn test_eval_or_block_return_propagates_from_for_in_header() {
    mut e := create()
    e.run_text('
fn maybe_arr() ?[]int {
    return none
}

fn maybe_int() ?int {
    return none
}

fn maybe_two() ?int {
    return 2
}

fn iterable() int {
    for x in (maybe_arr() or {
        return 7
    }) {
        _ = x
    }
    return 0
}

fn range_start() int {
    for i in (maybe_int() or {
        return 8
    }) .. 3 {
        _ = i
    }
    return 0
}

fn range_end() int {
    for i in 0 .. (maybe_int() or {
        return 9
    }) {
        _ = i
    }
    return 0
}

fn main() {
    println(int_str(iterable()))
    println(int_str(range_start()))
    println(int_str(range_end()))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '7\n8\n9\n'
}

fn test_eval_or_block_return_propagates_from_flow_contexts() {
    mut e := create()
    e.run_text('
fn maybe_bool() ?bool {
    return none
}

fn maybe_arr() ?[]int {
    return none
}

fn maybe_int() ?int {
    return none
}

fn maybe_two() ?int {
    return 2
}

fn if_condition() int {
    if maybe_bool() or {
        return 1
    } {
        return 99
    }
    return 0
}

fn assert_condition() bool {
    assert maybe_bool() or {
        return false
    }
    return true
}

fn loop_condition() int {
    for maybe_bool() or {
        return 5
    } {
        return 99
    }
    return 0
}

fn index_receiver() int {
    x := (maybe_arr() or {
        return 6
    })[0]
    return x
}

fn index_value() int {
    arr := [10]
    x := arr[maybe_int() or {
        return 7
    }]
    return x
}

fn if_expr_branch() int {
    x := if true {
        maybe_int() or {
            return 8
        }
    } else {
        0
    }
    return x
}

fn if_guard_scope() int {
    x := 1
    if x := maybe_two() {
        if x != 2 {
            return 99
        }
    }
    return x
}

fn main() {
    println(int_str(if_condition()))
    println(assert_condition())
    println(int_str(loop_condition()))
    println(int_str(index_receiver()))
    println(int_str(index_value()))
    println(int_str(if_expr_branch()))
    println(int_str(if_guard_scope()))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '1\nfalse\n5\n6\n7\n8\n1\n'
}

fn test_eval_or_block_return_propagates_from_array_literal_element() {
    mut e := create()
    e.run_text('
fn maybe() ?int {
    return none
}

fn run() []int {
    _ := [maybe() or {
        return [7]
    }]
    return [0]
}

fn main() {
    println(int_str(run()[0]))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '7\n'
}

fn test_eval_or_block_return_propagates_from_struct_init_field() {
    mut e := create()
    e.run_text('
struct S {
    n int
}

fn maybe() ?int {
    return none
}

fn run() S {
    return S{
        n: maybe() or {
            return S{
                n: 7
            }
        }
    }
}

fn main() {
    println(int_str(run().n))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '7\n'
}

fn test_eval_or_block_return_propagates_from_string_interpolation() {
    mut e := create()
    e.run_text('
fn maybe() ?int {
    return none
}

fn run() int {
    _ := "\${maybe() or {
        return 7
    }}"
    return 9
}

fn main() {
    println(int_str(run()))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '7\n'
}

fn test_eval_match_expression_propagates_branch_return() {
    mut e := create()
    e.run_text('
fn run(n int) int {
    x := match n {
        0 {
            return 12
        }
        else {
            7
        }
    }
    return x + 1
}

fn main() {
    println(int_str(run(0)))
    println(int_str(run(1)))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '12\n8\n'
}

fn test_eval_module_const_uses_defining_module_context() {
    dir := os.join_path(os.temp_dir(), 'v3_eval_const_module_${os.getpid()}')
    os.rmdir_all(dir) or {}
    os.mkdir_all(dir) or { panic(err) }
    defer {
        os.rmdir_all(dir) or {}
    }
    mod_file := os.join_path(dir, 'm.v')
    main_file := os.join_path(dir, 'main.v')
    os.write_file(mod_file, '
module m

const x = helper()

fn helper() int {
    return 7
}
') or {
        panic(err)
    }
    os.write_file(main_file, '
module main

import m

fn helper() int {
    return 99
}

fn main() {
    println(int_str(m.x))
}
') or {
        panic(err)
    }
    mut e := create()
    mut p := parser.Parser.new(&e.prefs)
    p.parse_files([mod_file, main_file])
    e.run_files(p.a) or { panic(err) }
    assert e.stdout() == '7\n'
}

fn test_eval_enum_initializers_use_declaring_module_context() {
    dir := os.join_path(os.temp_dir(), 'v3_eval_enum_module_${os.getpid()}')
    os.rmdir_all(dir) or {}
    os.mkdir_all(dir) or { panic(err) }
    defer {
        os.rmdir_all(dir) or {}
    }
    mod_file := os.join_path(dir, 'm.v')
    main_file := os.join_path(dir, 'main.v')
    os.write_file(mod_file, '
module m

const base = 2

pub enum E {
    a = base
    b
}

pub fn value() int {
    return int(E.a) * 10 + int(E.b)
}
') or {
        panic(err)
    }
    os.write_file(main_file, '
module main

import m

const base = 10

fn main() {
    println(int_str(m.value()))
}
') or {
        panic(err)
    }
    mut e := create()
    mut p := parser.Parser.new(&e.prefs)
    p.parse_files([mod_file, main_file])
    e.run_files(p.a) or { panic(err) }
    assert e.stdout() == '23\n'
}

fn test_eval_enum_initializers_use_file_import_aliases() {
    dir := os.join_path(os.temp_dir(), 'v3_eval_enum_alias_${os.getpid()}')
    os.rmdir_all(dir) or {}
    os.mkdir_all(dir) or { panic(err) }
    defer {
        os.rmdir_all(dir) or {}
    }
    dep_file := os.join_path(dir, 'dep.v')
    main_file := os.join_path(dir, 'main.v')
    os.write_file(dep_file, '
module dep

pub const n = 7
    ') or { panic(err) }
    os.write_file(main_file, '
module main

import dep as d

enum E {
    a = d.n
}

fn main() {
    println(int_str(int(E.a)))
}
    ') or {
        panic(err)
    }
    mut e := create()
    mut p := parser.Parser.new(&e.prefs)
    p.parse_files([main_file, dep_file])
    e.run_files(p.a) or { panic(err) }
    assert e.stdout() == '7\n'
}

fn test_eval_global_initializers_run_after_registration_in_declaring_module() {
    dir := os.join_path(os.temp_dir(), 'v3_eval_global_init_${os.getpid()}')
    os.rmdir_all(dir) or {}
    os.mkdir_all(dir) or { panic(err) }
    defer {
        os.rmdir_all(dir) or {}
    }
    main_file := os.join_path(dir, 'main.v')
    mod_file := os.join_path(dir, 'm.v')
    os.write_file(mod_file, '
module m

__global g = helper()

fn helper() int {
    return 7
}

pub fn value() int {
    return g
}
    ') or {
        panic(err)
    }
    os.write_file(main_file, '
module main

import m

fn helper() int {
    return 99
}

__global main_g = helper()

fn main() {
    println(int_str(main_g))
    println(int_str(m.value()))
}
    ') or {
        panic(err)
    }
    mut e := create()
    mut p := parser.Parser.new(&e.prefs)
    p.parse_files([main_file, mod_file])
    e.run_files(p.a) or { panic(err) }
    assert e.stdout() == '99\n7\n'
}

fn test_eval_global_initializers_run_imports_before_main() {
    dir := os.join_path(os.temp_dir(), 'v3_eval_global_init_order_${os.getpid()}')
    os.rmdir_all(dir) or {}
    os.mkdir_all(dir) or { panic(err) }
    defer {
        os.rmdir_all(dir) or {}
    }
    main_file := os.join_path(dir, 'main.v')
    mod_file := os.join_path(dir, 'm.v')
    os.write_file(mod_file, '
module m

__global g = 7

pub fn value() int {
    return g
}
    ') or {
        panic(err)
    }
    os.write_file(main_file, '
module main

import m

__global x = m.value()

fn main() {
    println(int_str(x))
}
    ') or {
        panic(err)
    }
    mut e := create()
    mut p := parser.Parser.new(&e.prefs)
    p.parse_files([main_file, mod_file])
    e.run_files(p.a) or { panic(err) }
    assert e.stdout() == '7\n'
}

fn test_eval_module_inits_run_dependencies_first() {
    dir := os.join_path(os.temp_dir(), 'v3_eval_init_order_${os.getpid()}')
    os.rmdir_all(dir) or {}
    os.mkdir_all(dir) or { panic(err) }
    defer {
        os.rmdir_all(dir) or {}
    }
    main_file := os.join_path(dir, 'main.v')
    moda_file := os.join_path(dir, 'moda.v')
    modb_file := os.join_path(dir, 'modb.v')
    os.write_file(modb_file, '
module modb

__global flag int

fn init() {
    flag = 41
}

pub fn value() int {
    return flag
}
    ') or {
        panic(err)
    }
    os.write_file(moda_file, '
module moda

import modb

__global seen int

fn init() {
    seen = modb.value()
}

pub fn value() int {
    return seen
}
    ') or {
        panic(err)
    }
    os.write_file(main_file, '
module main

import moda

fn main() {
    println(int_str(moda.value()))
}
    ') or {
        panic(err)
    }
    mut e := create()
    mut p := parser.Parser.new(&e.prefs)
    p.parse_files([main_file, moda_file, modb_file])
    e.run_files(p.a) or { panic(err) }
    assert e.stdout() == '41\n'
}

fn test_eval_struct_metadata_uses_current_module() {
    dir := os.join_path(os.temp_dir(), 'v3_eval_struct_scope_${os.getpid()}')
    os.rmdir_all(dir) or {}
    os.mkdir_all(dir) or { panic(err) }
    defer {
        os.rmdir_all(dir) or {}
    }
    main_file := os.join_path(dir, 'main.v')
    mod_file := os.join_path(dir, 'm.v')
    os.write_file(main_file, '
module main

import m

struct Point {
    x int
}

fn main() {
    p := Point{}
    println(int_str(p.x))
}
') or {
        panic(err)
    }
    os.write_file(mod_file, '
module m

struct Point {
    y int
}
') or { panic(err) }
    mut e := create()
    mut p := parser.Parser.new(&e.prefs)
    p.parse_files([main_file, mod_file])
    e.run_files(p.a) or { panic(err) }
    assert e.stdout() == '0\n'
}

fn test_eval_struct_field_defaults_use_declaring_module() {
    dir := os.join_path(os.temp_dir(), 'v3_eval_struct_field_module_${os.getpid()}')
    os.rmdir_all(dir) or {}
    os.mkdir_all(dir) or { panic(err) }
    defer {
        os.rmdir_all(dir) or {}
    }
    main_file := os.join_path(dir, 'main.v')
    mod_file := os.join_path(dir, 'm.v')
    os.write_file(mod_file, '
module m

pub struct Inner {
    x int
}

pub struct Outer {
    inner Inner
}

pub fn outer_x(o Outer) int {
    return o.inner.x
}
') or {
        panic(err)
    }
    os.write_file(main_file, '
module main

import m

struct Inner {
    y int
}

fn main() {
    outer := m.Outer{}
    println(int_str(m.outer_x(outer)))
}
') or {
        panic(err)
    }
    mut e := create()
    mut p := parser.Parser.new(&e.prefs)
    p.parse_files([main_file, mod_file])
    e.run_files(p.a) or { panic(err) }
    assert e.stdout() == '0\n'
}

fn test_eval_struct_field_default_initializers_are_preserved() {
    dir := os.join_path(os.temp_dir(), 'v3_eval_struct_field_defaults_${os.getpid()}')
    os.rmdir_all(dir) or {}
    os.mkdir_all(dir) or { panic(err) }
    defer {
        os.rmdir_all(dir) or {}
    }
    main_file := os.join_path(dir, 'main.v')
    mod_file := os.join_path(dir, 'm.v')
    os.write_file(mod_file, '
module m

pub struct S {
pub:
    n int = helper()
}

fn helper() int {
    return 7
}
    ') or {
        panic(err)
    }
    os.write_file(main_file, '
module main

import m

struct S {
    n int = helper()
}

fn helper() int {
    return 3
}

fn main() {
    println(int_str(S{}.n))
    println(int_str(m.S{}.n))
}
    ') or {
        panic(err)
    }
    mut e := create()
    mut p := parser.Parser.new(&e.prefs)
    p.parse_files([main_file, mod_file])
    e.run_files(p.a) or { panic(err) }
    assert e.stdout() == '3\n7\n'
}

fn test_eval_import_alias_struct_init_resolves_real_module() {
    dir := os.join_path(os.temp_dir(), 'v3_eval_import_alias_struct_${os.getpid()}')
    os.rmdir_all(dir) or {}
    os.mkdir_all(dir) or { panic(err) }
    defer {
        os.rmdir_all(dir) or {}
    }
    main_file := os.join_path(dir, 'main.v')
    mod_file := os.join_path(dir, 'm.v')
    os.write_file(mod_file, '
module m

pub struct S {
pub:
    n int = 7
}
    ') or { panic(err) }
    os.write_file(main_file, '
module main

import m as mm

fn main() {
    println(int_str(mm.S{}.n))
}
    ') or {
        panic(err)
    }
    mut e := create()
    mut p := parser.Parser.new(&e.prefs)
    p.parse_files([main_file, mod_file])
    e.run_files(p.a) or { panic(err) }
    assert e.stdout() == '7\n'
}

fn test_eval_zero_array_field_qualifies_imported_element_type() {
    dir := os.join_path(os.temp_dir(), 'v3_eval_import_array_elem_${os.getpid()}')
    os.rmdir_all(dir) or {}
    os.mkdir_all(dir) or { panic(err) }
    defer {
        os.rmdir_all(dir) or {}
    }
    main_file := os.join_path(dir, 'main.v')
    mod_file := os.join_path(dir, 'm.v')
    os.write_file(mod_file, '
module m

pub struct Item {}

pub struct Box {
pub mut:
    xs []Item
}
    ') or {
        panic(err)
    }
    os.write_file(main_file, '
module main

import m

fn main() {
    mut b := m.Box{}
    b.xs << [m.Item{}, m.Item{}]
    println(int_str(b.xs.len))
}
    ') or {
        panic(err)
    }
    mut e := create()
    mut p := parser.Parser.new(&e.prefs)
    p.parse_files([main_file, mod_file])
    e.run_files(p.a) or { panic(err) }
    assert e.stdout() == '2\n'
}

fn test_eval_is_checks_keep_module_qualified_types_distinct() {
    dir := os.join_path(os.temp_dir(), 'v3_eval_type_scope_${os.getpid()}')
    os.rmdir_all(dir) or {}
    os.mkdir_all(dir) or { panic(err) }
    defer {
        os.rmdir_all(dir) or {}
    }
    main_file := os.join_path(dir, 'main.v')
    mod_file := os.join_path(dir, 'm.v')
    os.write_file(mod_file, '
module m

pub struct Foo {}
') or { panic(err) }
    os.write_file(main_file, '
module main

import m

struct Foo {}

type Any = Foo | m.Foo

fn classify(x Any) string {
    if x is Foo {
        return "local"
    }
    if x is m.Foo {
        return "module"
    }
    return "none"
}

fn main() {
    println(classify(m.Foo{}))
}
') or {
        panic(err)
    }
    mut e := create()
    mut p := parser.Parser.new(&e.prefs)
    p.parse_files([main_file, mod_file])
    e.run_files(p.a) or { panic(err) }
    assert e.stdout() == 'module\n'
}

fn test_eval_module_sum_type_keeps_primitive_variants_unqualified() {
    dir := os.join_path(os.temp_dir(), 'v3_eval_primitive_type_scope_${os.getpid()}')
    os.rmdir_all(dir) or {}
    os.mkdir_all(dir) or { panic(err) }
    defer {
        os.rmdir_all(dir) or {}
    }
    main_file := os.join_path(dir, 'main.v')
    mod_file := os.join_path(dir, 'm.v')
    os.write_file(mod_file, '
module m

pub type Any = u32 | string

pub fn classify(x Any) string {
    if x is u32 {
        return "u32"
    }
    if x is string {
        return "string"
    }
    return "none"
}
    ') or {
        panic(err)
    }
    os.write_file(main_file, '
module main

import m

fn main() {
    println(m.classify(u32(7)))
    println(m.classify("ok"))
}
    ') or {
        panic(err)
    }
    mut e := create()
    mut p := parser.Parser.new(&e.prefs)
    p.parse_files([main_file, mod_file])
    e.run_files(p.a) or { panic(err) }
    assert e.stdout() == 'u32\nstring\n'
}

fn test_eval_sum_tables_are_module_scoped_and_exact() {
    dir := os.join_path(os.temp_dir(), 'v3_eval_sum_scope_${os.getpid()}')
    os.rmdir_all(dir) or {}
    os.mkdir_all(dir) or { panic(err) }
    defer {
        os.rmdir_all(dir) or {}
    }
    main_file := os.join_path(dir, 'main.v')
    mod_file := os.join_path(dir, 'm.v')
    os.write_file(mod_file, '
module m

pub struct Foo {}

pub type Any = string | bool

pub fn variant_index() int {
    x := Any("s")
    return x._typ
}
    ') or {
        panic(err)
    }
    os.write_file(main_file, '
module main

import m

struct Foo {}

type Any = int | string
type Both = Foo | m.Foo

fn local_variant_index() int {
    x := Any("s")
    return x._typ
}

fn imported_variant_index() int {
    x := Both(m.Foo{})
    return x._typ
}

fn main() {
    println(int_str(local_variant_index()))
    println(int_str(m.variant_index()))
    println(int_str(imported_variant_index()))
}
    ') or {
        panic(err)
    }
    mut e := create()
    mut p := parser.Parser.new(&e.prefs)
    p.parse_files([main_file, mod_file])
    e.run_files(p.a) or { panic(err) }
    assert e.stdout() == '1\n0\n1\n'
}

fn test_eval_is_checks_respect_container_element_types() {
    mut e := create()
    e.run_text('
type Any = []int | []string | map[string]int | map[string]string

fn classify(x Any) string {
    if x is []string {
        return "strings"
    }
    if x is []int {
        return "ints"
    }
    if x is map[string]string {
        return "string-map"
    }
    if x is map[string]int {
        return "int-map"
    }
    return "none"
}

fn main() {
    println(classify([]int{len: 1, init: 1}))
    println(classify([]string{len: 1, init: "s"}))
    mut mi := map[string]int{}
    mi["a"] = 1
    println(classify(mi))
    mut ms := map[string]string{}
    ms["a"] = "s"
    println(classify(ms))
}
    ') or {
        panic(err)
    }
    assert e.stdout() == 'ints\nstrings\nint-map\nstring-map\n'
}

fn test_eval_primitive_str_methods_are_direct() {
    mut e := create()
    e.run_text('
fn main() {
    total := 42
    println(total.str())
    println(true.str())
    f := 1.5
    println(f.str())
}
    ') or {
        panic(err)
    }
    assert e.stdout() == '42\ntrue\n1.5\n'
}

fn test_eval_enum_stringification_uses_field_names() {
    mut e := create()
    e.run_text('
enum State {
    idle
    busy = 10
}

fn main() {
    println(State.busy)
    println("\${State.idle}")
}
    ') or {
        panic(err)
    }
    assert e.stdout() == 'busy\nidle\n'
}

fn test_eval_struct_stringification_matches_v_output() {
    mut e := create()
    e.run_text('
struct Point {
    x int
}

struct User {
    name string
    age  int
}

struct Custom {
    n int
}

fn (c Custom) str() string {
    return "custom " + int_str(c.n)
}

fn main() {
    println(Point{x: 1})
    println(User{name: "Ada", age: 2})
    println(Custom{n: 3})
    println("\${Custom{n: 4}}")
}
    ') or {
        panic(err)
    }
    assert e.stdout() == "Point{
    x: 1
}
User{
    name: 'Ada'
    age: 2
}
custom 3
custom 4
"
}

fn test_eval_os_join_path_delegates_to_os() {
    mut e := create()
    e.run_text('
import os

fn main() {
    println(os.join_path("", "foo"))
    println(os.join_path("foo", ""))
}
    ') or {
        panic(err)
    }
    expected := os.join_path('', 'foo') + '\n' + os.join_path('foo', '') + '\n'
    assert e.stdout() == expected
}

fn test_v3_eval_backend_cli() {
    v3_bin := os.join_path(os.temp_dir(), 'v3_eval_backend_test')
    build := os.execute('${vexe} -o ${v3_bin} ${v3_src}')
    assert build.exit_code == 0
    src := os.join_path(os.temp_dir(), 'v3_eval_backend_sample.v')
    os.write_file(src, '
fn main() {
    mut total := 0
    for i in 0 .. 7 {
        total += i
    }
    println(int_str(total))
}
') or {
        panic(err)
    }
    result := os.execute('${v3_bin} ${src} -b eval')
    assert result.exit_code == 0
    assert result.output.contains('21\n')
}