module eval

import os
import strconv
import time
import v3.flat
import v3.parser
import v3.pref

pub type Value = ArrayValue
    | EnumValue
    | FnValue
    | MapValue
    | ModuleValue
    | RangeValue
    | StructValue
    | SumValue
    | TupleValue
    | TypeValue
    | VoidValue
    | bool
    | f64
    | i64
    | string

pub struct ArrayValue {
pub mut:
    elem_type_name string
    values         []Value
}

pub struct EnumValue {
pub:
    type_name string
    value     i64
}

pub struct FnValue {
    node          flat.NodeId
    module_name   string
    file_name     string
    captures      map[string]Value
    capture_types map[string]string
}

pub struct MapEntry {
pub:
    key Value
pub mut:
    value Value
}

pub struct MapValue {
pub mut:
    key_type_name   string
    value_type_name string
    default_value   Value
    entries         []MapEntry
}

pub struct ModuleValue {
pub:
    name string
}

pub struct RangeValue {
pub:
    start     i64
    end       i64
    inclusive bool
}

pub struct StructValue {
pub:
    type_name string
pub mut:
    fields map[string]Value
}

pub struct SumValue {
pub:
    type_name    string
    variant_name string
pub mut:
    payload Value
}

pub struct TupleValue {
pub:
    values []Value
}

pub struct TypeValue {
pub:
    name string
}

pub struct VoidValue {}

struct FunctionDef {
    node        flat.NodeId
    name        string
    module_name string
    file_name   string
}

struct ConstEntry {
    node        flat.NodeId
    module_name string
    file_name   string
mut:
    cached     bool
    evaluating bool
    value      Value
}

struct GlobalEntry {
    name         string
    typ          string
    default_node flat.NodeId
    module_name  string
    file_name    string
}

struct EnumInitEntry {
    node        flat.NodeId
    module_name string
    file_name   string
}

struct TopLevelStmt {
    node        flat.NodeId
    module_name string
    file_name   string
}

struct StructInfo {
    module_name string
    name        string
mut:
    fields []FieldInfo
}

struct TypeAliasInfo {
    module_name string
    target      string
}

struct FieldInfo {
    name         string
    typ          string
    default_node flat.NodeId
    module_name  string
    file_name    string
}

struct ScopeFrame {
mut:
    vars        map[string]Value
    types       map[string]string
    defer_stmts []flat.NodeId
}

struct CallFrame {
    module_name string
    file_name   string
    fn_name     string
    return_type string
    scope_idx   int = -1
}

struct MaybeValue {
    found bool
    value Value
}

struct SmartcastBinding {
    name      string
    value     Value
    type_name string
}

struct CallResult {
    values           []Value
    mutated_args     map[int]Value
    fn_value_changed bool
    fn_value         FnValue
}

struct MethodCallResult {
    value            Value
    receiver_changed bool
    receiver         Value
    mutated_args     map[int]Value
}

struct LvalueStep {
    kind       flat.NodeKind
    container  Value
    index      Value
    field_name string
}

struct ResolvedLvalue {
mut:
    signal  FlowSignal
    root_id flat.NodeId
    value   Value
    steps   []LvalueStep
}

struct InfixOperatorCallInfo {
    target  FunctionDef
    reverse bool
    negate  bool
}

enum FlowKind {
    normal
    break_
    continue_
    return_
}

struct FlowSignal {
    kind        FlowKind
    label       string
    values      []Value
    mut_lvalues map[int]ResolvedLvalue
}

// Eval interprets v3 flat AST nodes directly for a practical subset of V.
pub struct Eval {
pub mut:
    capture_output bool
    prefs          pref.Preferences
mut:
    a                 &flat.FlatAst = unsafe { nil }
    stdout_data       string
    stderr_data       string
    functions         map[string]map[string]FunctionDef
    consts            map[string]map[string]ConstEntry
    globals           map[string]map[string]Value
    global_types      map[string]map[string]string
    global_inits      []GlobalEntry
    enum_inits        []EnumInitEntry
    implicit_main     []TopLevelStmt
    structs           map[string]StructInfo
    enum_fields       map[string][]string
    sum_types         map[string][]string
    type_aliases      map[string]TypeAliasInfo
    type_names        map[string]map[string]bool
    module_imports    map[string][]string
    module_order      []string
    file_import_alias map[string]map[string]string
    modules           map[string]bool
    scopes            []ScopeFrame
    call_stack        []CallFrame
}

// new returns a new evaluator configured for direct execution.
pub fn new(prefs_ &pref.Preferences) Eval {
    return Eval{
        prefs: *prefs_
    }
}

// create returns a capturing evaluator convenient for tests.
pub fn create() Eval {
    return Eval{
        capture_output: true
        prefs:          pref.new_preferences()
    }
}

// stdout returns the captured stdout stream.
pub fn (e &Eval) stdout() string {
    return e.stdout_data
}

// stderr returns the captured stderr stream.
pub fn (e &Eval) stderr() string {
    return e.stderr_data
}

// run_text parses and executes a single V source string.
pub fn (mut e Eval) run_text(code string) ![]Value {
    tmp_file := os.join_path(os.temp_dir(), 'v3_eval_${os.getpid()}_${time.now().unix_micro()}.v')
    os.write_file(tmp_file, code)!
    defer {
        os.rm(tmp_file) or {}
    }
    mut p := parser.Parser.new(&e.prefs)
    p.parse_into(tmp_file)
    return e.run_files(p.a)
}

// run_files executes parsed flat AST files and invokes `main.main`.
pub fn (mut e Eval) run_files(a &flat.FlatAst) ![]Value {
    e.reset(a)
    e.register_files()!
    e.run_inits()!
    if e.has_main_function() {
        return e.call_function('main', 'main', []Value{})!.values
    }
    return e.run_implicit_main()
}

fn void_value() Value {
    return VoidValue{}
}

fn normal_flow() FlowSignal {
    return FlowSignal{
        kind: .normal
    }
}

fn value_flow(value Value) FlowSignal {
    return FlowSignal{
        values: [value]
    }
}

fn (mut e Eval) reset(a &flat.FlatAst) {
    e.a = unsafe { a }
    e.stdout_data = ''
    e.stderr_data = ''
    e.functions = map[string]map[string]FunctionDef{}
    e.consts = map[string]map[string]ConstEntry{}
    e.globals = map[string]map[string]Value{}
    e.global_types = map[string]map[string]string{}
    e.global_inits = []GlobalEntry{}
    e.enum_inits = []EnumInitEntry{}
    e.implicit_main = []TopLevelStmt{}
    e.structs = map[string]StructInfo{}
    e.enum_fields = map[string][]string{}
    e.sum_types = map[string][]string{}
    e.type_aliases = map[string]TypeAliasInfo{}
    e.type_names = map[string]map[string]bool{}
    e.module_imports = map[string][]string{}
    e.module_order = []string{}
    e.file_import_alias = map[string]map[string]string{}
    e.modules = map[string]bool{}
    e.scopes = []ScopeFrame{}
    e.call_stack = []CallFrame{}
}

fn (e &Eval) node(id flat.NodeId) &flat.Node {
    return e.a.node(id)
}

fn (e &Eval) child(node &flat.Node, index int) flat.NodeId {
    return e.a.child(node, index)
}

fn (e &Eval) child_node(node &flat.Node, index int) &flat.Node {
    return e.a.child_node(node, index)
}

fn (e &Eval) children(node &flat.Node) []flat.NodeId {
    return e.a.children_of(node)
}

fn (mut e Eval) ensure_module_maps(module_name string) {
    if module_name !in e.functions {
        e.functions[module_name] = map[string]FunctionDef{}
    }
    if module_name !in e.consts {
        e.consts[module_name] = map[string]ConstEntry{}
    }
    if module_name !in e.globals {
        e.globals[module_name] = map[string]Value{}
    }
    if module_name !in e.global_types {
        e.global_types[module_name] = map[string]string{}
    }
    if module_name !in e.type_names {
        e.type_names[module_name] = map[string]bool{}
    }
}

fn (e &Eval) top_level_registration_children(node &flat.Node) []flat.NodeId {
    mut ids := []flat.NodeId{}
    for child_id in e.children(node) {
        child := e.node(child_id)
        if child.kind == .block {
            ids << e.top_level_registration_children(child)
            continue
        }
        ids << child_id
    }
    return ids
}

fn (e &Eval) has_main_function() bool {
    return 'main' in e.functions && 'main' in e.functions['main']
}

fn is_top_level_declaration_kind(kind flat.NodeKind) bool {
    match kind {
        .empty, .module_decl, .import_decl, .directive, .fn_decl, .c_fn_decl, .struct_decl,
        .field_decl, .global_decl, .const_decl, .const_field, .enum_decl, .enum_field, .type_decl,
        .interface_decl, .interface_field, .param, .comptime_if, .comptime_for {
            return true
        }
        else {
            return false
        }
    }
}

fn (mut e Eval) register_implicit_main_stmt(module_name string, file_name string, id flat.NodeId, node &flat.Node) {
    if module_name != 'main' || is_top_level_declaration_kind(node.kind) {
        return
    }
    e.implicit_main << TopLevelStmt{
        node:        id
        module_name: module_name
        file_name:   file_name
    }
}

fn (mut e Eval) register_files() ! {
    for file_id, file_node in e.a.nodes {
        if file_node.kind != .file || file_node.children_count == 0 {
            continue
        }
        file_name := file_node.value
        top_level_children := e.top_level_registration_children(&file_node)
        mut module_name := 'main'
        for child_id in top_level_children {
            child := e.node(child_id)
            if child.kind == .module_decl {
                module_name = child.value
                break
            }
        }
        if module_name !in e.modules {
            e.module_order << module_name
        }
        e.modules[module_name] = true
        e.ensure_module_maps(module_name)
        if module_name !in e.module_imports {
            e.module_imports[module_name] = []string{}
        }
        mut import_aliases := map[string]string{}
        for child_id in top_level_children {
            child := e.node(child_id)
            if child.kind != .import_decl {
                continue
            }
            imported_module := child.value.all_after_last('.')
            if imported_module.len > 0 && imported_module != module_name
                && imported_module !in e.module_imports[module_name] {
                e.module_imports[module_name] << imported_module
            }
            import_aliases[child.typ] = imported_module
            import_aliases[imported_module] = imported_module
        }
        e.file_import_alias[file_name] = import_aliases.clone()
        for child_id in top_level_children {
            child := e.node(child_id)
            match child.kind {
                .import_decl {}
                .const_decl {
                    for field_id in e.children(child) {
                        field := e.node(field_id)
                        if field.kind != .const_field {
                            continue
                        }
                        e.consts[module_name][field.value] = ConstEntry{
                            node:        field_id
                            module_name: module_name
                            file_name:   file_name
                            value:       void_value()
                        }
                    }
                }
                .global_decl {
                    for field_id in e.children(child) {
                        field := e.node(field_id)
                        if field.kind != .field_decl {
                            continue
                        }
                        e.global_inits << GlobalEntry{
                            name:         field.value
                            typ:          field.typ
                            default_node: if field.children_count > 0 {
                                e.child(field, 0)
                            } else {
                                flat.empty_node
                            }
                            module_name:  module_name
                            file_name:    file_name
                        }
                        e.global_types[module_name][field.value] = e.qualify_nested_type_name(module_name,
                            field.typ)
                    }
                }
                .enum_decl {
                    e.type_names[module_name][child.value] = true
                    enum_name := e.qualify_type_name(module_name, child.value)
                    mut enum_fields := []string{}
                    for field_id in e.children(child) {
                        field := e.node(field_id)
                        if field.kind != .enum_field {
                            continue
                        }
                        enum_fields << field.value
                    }
                    e.enum_fields[enum_name] = enum_fields
                    if module_name in ['main', 'builtin'] {
                        e.enum_fields[child.value] = enum_fields
                    }
                    e.enum_inits << EnumInitEntry{
                        node:        child_id
                        module_name: module_name
                        file_name:   file_name
                    }
                }
                .fn_decl {
                    e.register_function(module_name, file_name, child_id, child)
                }
                .struct_decl {
                    e.type_names[module_name][child.value] = true
                    mut fields := []FieldInfo{}
                    for field_id in e.children(child) {
                        field := e.node(field_id)
                        if field.kind == .field_decl {
                            fields << FieldInfo{
                                name:         field.value
                                typ:          field.typ
                                default_node: if field.children_count > 0 {
                                    e.child(field, 0)
                                } else {
                                    flat.empty_node
                                }
                                module_name:  module_name
                                file_name:    file_name
                            }
                        }
                    }
                    info := StructInfo{
                        module_name: module_name
                        name:        child.value
                        fields:      fields
                    }
                    qualified_name := e.qualify_type_name(module_name, child.value)
                    e.structs[qualified_name] = info
                    if module_name in ['main', 'builtin'] {
                        e.structs[child.value] = info
                    }
                }
                .type_decl {
                    e.type_names[module_name][child.value] = true
                    if child.children_count > 0 {
                        mut variants := []string{}
                        for variant_id in e.children(child) {
                            variant := e.node(variant_id)
                            variants << e.qualify_type_name(module_name, variant.value)
                        }
                        qualified_name := e.qualify_type_name(module_name, child.value)
                        e.sum_types[qualified_name] = variants
                        if module_name in ['main', 'builtin'] {
                            e.sum_types[child.value] = variants
                        }
                    } else if child.typ.len > 0 {
                        info := TypeAliasInfo{
                            module_name: module_name
                            target:      child.typ
                        }
                        qualified_name := e.qualify_type_name(module_name, child.value)
                        e.type_aliases[qualified_name] = info
                        if module_name in ['main', 'builtin'] {
                            e.type_aliases[child.value] = info
                        }
                    }
                }
                else {
                    e.register_implicit_main_stmt(module_name, file_name, child_id, child)
                }
            }
        }
        _ = file_id
    }
    e.evaluate_enum_inits()!
    e.evaluate_global_inits()!
    if !e.has_main_function() && e.implicit_main.len == 0 {
        return error('v3.eval: missing main.main entry point')
    }
}

fn (mut e Eval) evaluate_enum_inits() ! {
    for entry in e.enum_inits {
        node := e.node(entry.node)
        mut next_value := if node.typ == 'flag' { i64(1) } else { i64(0) }
        for field_id in e.children(node) {
            field := e.node(field_id)
            if field.kind != .enum_field {
                continue
            }
            value := if field.children_count > 0 {
                e.value_as_int(e.eval_expr_in_module(e.child(field, 0), entry.module_name,
                    entry.file_name, '<enum ${node.value}.${field.value}>')!)!
            } else {
                next_value
            }
            e.consts[entry.module_name][field.value] = ConstEntry{
                node:        field_id
                module_name: entry.module_name
                file_name:   entry.file_name
                cached:      true
                value:       Value(value)
            }
            e.consts[entry.module_name]['${node.value}.${field.value}'] = ConstEntry{
                node:        field_id
                module_name: entry.module_name
                file_name:   entry.file_name
                cached:      true
                value:       Value(value)
            }
            next_value = if node.typ == 'flag' {
                if value <= 0 { i64(1) } else { value * 2 }
            } else {
                value + 1
            }
        }
    }
}

fn (mut e Eval) run_implicit_main() ![]Value {
    e.open_scope()
    scope_idx := e.scopes.len - 1
    mut frame := CallFrame{
        module_name: 'main'
        file_name:   if e.implicit_main.len > 0 { e.implicit_main[0].file_name } else { '' }
        fn_name:     'main'
        return_type: 'void'
        scope_idx:   scope_idx
    }
    e.call_stack << frame
    mut values := [void_value()]
    mut escaped := normal_flow()
    for stmt in e.implicit_main {
        frame = CallFrame{
            module_name: stmt.module_name
            file_name:   stmt.file_name
            fn_name:     'main'
            return_type: 'void'
            scope_idx:   scope_idx
        }
        e.call_stack[e.call_stack.len - 1] = frame
        signal := e.exec_stmt(stmt.node)!
        if signal.kind == .return_ {
            values = flow_values_or_void(signal.values)
            break
        }
        if signal.kind != .normal {
            escaped = signal
            break
        }
    }
    e.run_deferred_stmts()!
    e.close_scope()!
    e.call_stack.delete(e.call_stack.len - 1)
    if escaped.kind != .normal {
        return error('v3.eval: unexpected `${escaped.kind}` escaped implicit main')
    }
    return values
}

fn (mut e Eval) evaluate_global_inits() ! {
    mut entries_by_module := map[string][]GlobalEntry{}
    for entry in e.global_inits {
        mut entries := entries_by_module[entry.module_name]
        entries << entry
        entries_by_module[entry.module_name] = entries
    }
    mut visited := map[string]bool{}
    mut visiting := map[string]bool{}
    e.evaluate_module_global_inits('main', entries_by_module, mut visited, mut visiting)!
    for module_name in e.module_order {
        e.evaluate_module_global_inits(module_name, entries_by_module, mut visited, mut visiting)!
    }
}

fn (mut e Eval) evaluate_module_global_inits(module_name string, entries_by_module map[string][]GlobalEntry, mut visited map[string]bool, mut visiting map[string]bool) ! {
    if module_name in visited {
        return
    }
    if module_name in visiting {
        return
    }
    visiting[module_name] = true
    if module_name in e.module_imports {
        for imported_module in e.module_imports[module_name] {
            e.evaluate_module_global_inits(imported_module, entries_by_module, mut visited, mut
                visiting)!
        }
    }
    visiting.delete(module_name)
    visited[module_name] = true
    if module_name !in entries_by_module {
        return
    }
    for entry in entries_by_module[module_name] {
        e.evaluate_global_init(entry)!
    }
}

fn (mut e Eval) evaluate_global_init(entry GlobalEntry) ! {
    e.call_stack << CallFrame{
        module_name: entry.module_name
        file_name:   entry.file_name
        fn_name:     '<global ${entry.name}>'
    }
    value := if int(entry.default_node) >= 0 {
        e.eval_expr(entry.default_node)!
    } else {
        e.zero_value_for_type_name_in_module(entry.typ, entry.module_name)
    }
    e.call_stack.delete(e.call_stack.len - 1)
    e.globals[entry.module_name][entry.name] = e.adapt_value_to_type_name(value, entry.typ)
}

fn (mut e Eval) eval_expr_in_module(id flat.NodeId, module_name string, file_name string, label string) !Value {
    e.call_stack << CallFrame{
        module_name: module_name
        file_name:   file_name
        fn_name:     label
    }
    defer {
        e.call_stack.delete(e.call_stack.len - 1)
    }
    return e.eval_expr(id)
}

fn (mut e Eval) register_function(module_name string, file_name string, id flat.NodeId, node &flat.Node) {
    def := FunctionDef{
        node:        id
        name:        node.value
        module_name: module_name
        file_name:   file_name
    }
    e.functions[module_name][node.value] = def
    if module_name != 'main' && module_name != 'builtin' {
        e.functions[module_name]['${module_name}.${node.value}'] = def
    }
    if node.value.contains('.') {
        short := node.value.all_after_last('.')
        receiver := node.value.all_before_last('.').all_after_last('.')
        e.functions[module_name]['${receiver}.${short}'] = def
    }
}

fn (mut e Eval) run_inits() ! {
    mut visited := map[string]bool{}
    mut visiting := map[string]bool{}
    e.run_module_init('main', mut visited, mut visiting)!
    for module_name in e.module_order {
        e.run_module_init(module_name, mut visited, mut visiting)!
    }
}

fn (mut e Eval) run_module_init(module_name string, mut visited map[string]bool, mut visiting map[string]bool) ! {
    if module_name in visited {
        return
    }
    if module_name in visiting {
        return
    }
    visiting[module_name] = true
    if module_name in e.module_imports {
        for imported_module in e.module_imports[module_name] {
            e.run_module_init(imported_module, mut visited, mut visiting)!
        }
    }
    visiting.delete(module_name)
    visited[module_name] = true
    if module_name in e.functions && 'init' in e.functions[module_name] {
        e.call_function(module_name, 'init', []Value{})!
    }
}

fn (mut e Eval) open_scope() {
    e.scopes << ScopeFrame{
        vars:        map[string]Value{}
        types:       map[string]string{}
        defer_stmts: []flat.NodeId{}
    }
}

fn (mut e Eval) close_scope() ! {
    if e.scopes.len > 0 {
        e.run_deferred_stmts()!
        e.scopes.delete(e.scopes.len - 1)
    }
}

fn (mut e Eval) declare_var(name string, value Value) {
    e.declare_var_typed(name, value, '')
}

fn (mut e Eval) declare_var_typed(name string, value Value, type_name string) {
    if name == '_' {
        return
    }
    if e.scopes.len == 0 {
        e.open_scope()
    }
    e.scopes[e.scopes.len - 1].vars[name] = value
    normalized := e.normalize_type_name(type_name)
    if normalized.len > 0 {
        e.scopes[e.scopes.len - 1].types[name] = normalized
    }
}

fn (mut e Eval) set_var(name string, value Value) ! {
    if name == '_' {
        return
    }
    for i := e.scopes.len - 1; i >= 0; i-- {
        if name in e.scopes[i].vars {
            e.scopes[i].vars[name] = value
            return
        }
    }
    module_name := e.current_module_name()
    if module_name in e.globals && name in e.globals[module_name] {
        e.globals[module_name][name] = value
        return
    }
    return e.unknown_variable_error(name)
}

fn (mut e Eval) set_var_type(name string, type_name string) {
    normalized := e.normalize_type_name(type_name)
    if normalized.len == 0 {
        return
    }
    for i := e.scopes.len - 1; i >= 0; i-- {
        if name in e.scopes[i].vars {
            e.scopes[i].types[name] = normalized
            return
        }
    }
}

fn (e &Eval) lookup_var(name string) MaybeValue {
    for i := e.scopes.len - 1; i >= 0; i-- {
        if name in e.scopes[i].vars {
            return MaybeValue{
                found: true
                value: e.scopes[i].vars[name] or { void_value() }
            }
        }
    }
    module_name := e.current_module_name()
    if module_name in e.globals && name in e.globals[module_name] {
        return MaybeValue{
            found: true
            value: e.globals[module_name][name] or { void_value() }
        }
    }
    return MaybeValue{}
}

fn (e &Eval) lookup_var_type(name string) ?string {
    for i := e.scopes.len - 1; i >= 0; i-- {
        if name in e.scopes[i].types {
            return e.scopes[i].types[name]
        }
    }
    module_name := e.current_module_name()
    if module_name in e.global_types && name in e.global_types[module_name] {
        return e.global_types[module_name][name]
    }
    return none
}

fn (e &Eval) current_module_name() string {
    if e.call_stack.len == 0 {
        return 'main'
    }
    return e.call_stack[e.call_stack.len - 1].module_name
}

fn (e &Eval) current_file_name() string {
    if e.call_stack.len == 0 {
        return ''
    }
    return e.call_stack[e.call_stack.len - 1].file_name
}

fn (e &Eval) current_function_label() string {
    if e.call_stack.len == 0 {
        return '<top-level>'
    }
    frame := e.call_stack[e.call_stack.len - 1]
    return '${frame.module_name}.${frame.fn_name}'
}

fn (e &Eval) call_stack_trace() string {
    return e.call_stack.map('${it.module_name}.${it.fn_name}').join(' -> ')
}

fn (e &Eval) unknown_variable_error(name string) IError {
    return error('v3.eval: unknown variable `${name}` in `${e.current_function_label()}` stack `${e.call_stack_trace()}`')
}

fn (mut e Eval) call_function(module_name string, fn_name string, args []Value) !CallResult {
    builtin := e.maybe_call_builtin(module_name, fn_name, args)!
    if builtin.found {
        return CallResult{
            values: [builtin.value]
        }
    }
    target_module := if module_name == '' { e.current_module_name() } else { module_name }
    if target_module !in e.functions {
        return error('v3.eval: unknown module `${target_module}`')
    }
    if fn_name !in e.functions[target_module] {
        return error('v3.eval: unknown function `${target_module}.${fn_name}`')
    }
    def := e.functions[target_module][fn_name]
    node := e.node(def.node)
    mut params := []flat.NodeId{}
    mut body_start := 0
    for child_id in e.children(node) {
        child := e.node(child_id)
        if child.kind == .param {
            params << child_id
            body_start++
            continue
        }
        break
    }
    min_args := e.minimum_arg_count(params)
    if args.len < min_args {
        return error('v3.eval: `${target_module}.${fn_name}` expected ${min_args} arguments, got ${args.len}')
    }
    e.open_scope()
    e.call_stack << CallFrame{
        module_name: target_module
        file_name:   def.file_name
        fn_name:     fn_name
        return_type: node.typ
        scope_idx:   e.scopes.len - 1
    }
    e.bind_call_params(params, args)!
    mut body_ids := e.children(node)
    if body_start > 0 {
        body_ids = body_ids[body_start..].clone()
    }
    signal := e.exec_stmts(body_ids)!
    e.run_deferred_stmts()!
    mutated_args := e.collect_mutated_param_args(params, args)
    adapted_values := if signal.kind == .return_ {
        e.adapt_return_values(signal.values, node.typ)
    } else {
        []Value{}
    }
    e.close_scope()!
    e.call_stack.delete(e.call_stack.len - 1)
    if signal.kind == .return_ {
        return CallResult{
            values:       adapted_values
            mutated_args: mutated_args
        }
    }
    if signal.kind != .normal {
        return error('v3.eval: unexpected `${signal.kind}` escaped `${target_module}.${fn_name}`')
    }
    return CallResult{
        values:       [void_value()]
        mutated_args: mutated_args
    }
}

fn (mut e Eval) exec_stmts(stmts []flat.NodeId) !FlowSignal {
    mut i := 0
    for i < stmts.len {
        stmt_id := stmts[i]
        if int(stmt_id) >= 0 {
            node := e.node(stmt_id)
            if node.kind == .label_stmt && i + 1 < stmts.len {
                next_id := stmts[i + 1]
                if int(next_id) >= 0 {
                    next_node := e.node(next_id)
                    if next_node.kind == .for_stmt {
                        signal := e.exec_for(next_node, node.value)!
                        if signal.kind != .normal {
                            return signal
                        }
                        i += 2
                        continue
                    }
                    if next_node.kind == .for_in_stmt {
                        signal := e.exec_for_in(next_node, node.value)!
                        if signal.kind != .normal {
                            return signal
                        }
                        i += 2
                        continue
                    }
                }
            }
        }
        signal := e.exec_stmt(stmt_id)!
        if signal.kind != .normal {
            return signal
        }
        i++
    }
    return normal_flow()
}

fn (mut e Eval) exec_block(node &flat.Node) !FlowSignal {
    e.open_scope()
    signal := e.exec_stmts(e.children(node))!
    e.close_scope()!
    return signal
}

fn (mut e Eval) exec_stmt(id flat.NodeId) !FlowSignal {
    if int(id) < 0 {
        return normal_flow()
    }
    node := e.node(id)
    match node.kind {
        .block {
            return e.exec_block(node)
        }
        .expr_stmt {
            if node.children_count > 0 {
                expr_id := e.child(node, 0)
                expr := e.node(expr_id)
                if expr.kind == .infix && expr.op == .left_shift {
                    return e.exec_array_append(expr)
                } else {
                    signal := e.eval_expr_flow(expr_id)!
                    if signal.kind != .normal {
                        return signal
                    }
                }
            }
            return normal_flow()
        }
        .decl_assign {
            return e.exec_assign(node, true)
        }
        .assign, .selector_assign, .index_assign {
            return e.exec_assign(node, false)
        }
        .return_stmt {
            mut values := []Value{}
            return_type := e.current_return_type()
            return_types := split_multi_return_types(return_type)
            child_count := node.children_count
            mut child_index := 0
            for child_id in e.children(node) {
                expected_type := return_child_expected_type(return_type, return_types, child_index,
                    child_count)
                signal := e.eval_expr_flow_expected(child_id, expected_type)!
                if signal.kind != .normal {
                    return signal
                }
                expr_values := flow_values_or_void(signal.values)
                if expr_values.len > 1 {
                    values << expr_values
                    continue
                }
                value := expr_values[0]
                if value is TupleValue {
                    values << value.values
                } else {
                    values << value
                }
                child_index++
            }
            if values.len == 0 {
                values << void_value()
            }
            return FlowSignal{
                kind:   .return_
                values: values
            }
        }
        .if_expr {
            return e.exec_if(node)
        }
        .match_stmt {
            return e.exec_match(node)
        }
        .for_stmt {
            return e.exec_for(node, '')
        }
        .for_in_stmt {
            return e.exec_for_in(node, '')
        }
        .break_stmt {
            return FlowSignal{
                kind:  .break_
                label: node.value
            }
        }
        .continue_stmt {
            return FlowSignal{
                kind:  .continue_
                label: node.value
            }
        }
        .assert_stmt {
            cond_signal := e.eval_expr_flow(e.child(node, 0))!
            if cond_signal.kind != .normal {
                return cond_signal
            }
            cond := flow_value(cond_signal)
            if !e.value_as_bool(cond)! {
                mut msg := 'assertion failed'
                if node.children_count > 1 {
                    msg = e.display_string(e.eval_expr(e.child(node, 1))!)!
                }
                return error('v3.eval: ${msg}')
            }
            return normal_flow()
        }
        .defer_stmt {
            e.register_defer_stmt(id)
            return normal_flow()
        }
        .asm_stmt, .empty, .label_stmt {
            return normal_flow()
        }
        else {
            _ = e.eval_expr(id)!
            return normal_flow()
        }
    }
}

fn (mut e Eval) register_defer_stmt(id flat.NodeId) {
    if e.scopes.len == 0 {
        e.open_scope()
    }
    node := e.node(id)
    scope_idx := if node.value == 'function' && e.call_stack.len > 0
        && e.call_stack[e.call_stack.len - 1].scope_idx >= 0 {
        e.call_stack[e.call_stack.len - 1].scope_idx
    } else {
        e.scopes.len - 1
    }
    e.scopes[scope_idx].defer_stmts << id
}

fn (mut e Eval) run_deferred_stmts() ! {
    if e.scopes.len == 0 {
        return
    }
    scope_idx := e.scopes.len - 1
    defer_stmts := e.scopes[scope_idx].defer_stmts.clone()
    e.scopes[scope_idx].defer_stmts = []flat.NodeId{}
    for i := defer_stmts.len; i > 0; i-- {
        defer_id := defer_stmts[i - 1]
        defer_node := e.node(defer_id)
        for child_id in e.children(defer_node) {
            signal := e.exec_stmt(child_id)!
            if signal.kind != .normal {
                return error('v3.eval: unexpected `${signal.kind}` escaped defer')
            }
        }
    }
}

fn (mut e Eval) exec_assign(node &flat.Node, declare bool) !FlowSignal {
    children := e.children(node)
    if children.len == 0 {
        return normal_flow()
    }
    if children.len == 2 {
        lhs_id := children[0]
        rhs_id := children[1]
        if node.op != .assign && node.op != .none && e.target_needs_single_eval(lhs_id) {
            return e.exec_compound_assignment_pair_flow(node.op, lhs_id, rhs_id, declare)
        }
        target_type := e.assignment_target_type_name(lhs_id, declare)
        signal := e.assignment_value_flow(node.op, lhs_id, rhs_id, target_type)!
        if signal.kind != .normal {
            return signal
        }
        assign_signal := e.assign_target_typed_flow(lhs_id, flow_value(signal), declare, if target_type.len > 0 {
            target_type
        } else {
            e.infer_expr_type_name(rhs_id)
        })!
        if assign_signal.kind != .normal {
            return assign_signal
        }
        return normal_flow()
    }
    if children.len > 2 {
        first_target_type := e.assignment_target_type_name(children[0], declare)
        first_signal := e.assignment_value_flow(node.op, children[0], children[1],
            first_target_type)!
        if first_signal.kind != .normal {
            return first_signal
        }
        value := flow_value(first_signal)
        mut lhs_ids := [children[0]]
        for i := 2; i < children.len; i++ {
            lhs_ids << children[i]
        }
        if value is TupleValue {
            for i, lhs_id in lhs_ids {
                item := if i < value.values.len { value.values[i] } else { void_value() }
                assign_signal := e.assign_target_flow(lhs_id, item, declare)!
                if assign_signal.kind != .normal {
                    return assign_signal
                }
            }
            return normal_flow()
        }
        if children.len % 2 == 1 {
            for i, lhs_id in lhs_ids {
                item := if i == 0 { value } else { void_value() }
                assign_signal := e.assign_target_flow(lhs_id, item, declare)!
                if assign_signal.kind != .normal {
                    return assign_signal
                }
            }
            return normal_flow()
        }
        mut assign_lhs_ids := [children[0]]
        mut values := [value]
        mut i := 2
        for i < children.len {
            lhs_id := children[i]
            rhs_id := if i + 1 < children.len { children[i + 1] } else { flat.empty_node }
            item := if int(rhs_id) >= 0 {
                target_type := e.assignment_target_type_name(lhs_id, declare)
                signal := e.assignment_value_flow(node.op, lhs_id, rhs_id, target_type)!
                if signal.kind != .normal {
                    return signal
                }
                flow_value(signal)
            } else {
                void_value()
            }
            assign_lhs_ids << lhs_id
            values << item
            i += 2
        }
        for idx, lhs_id in assign_lhs_ids {
            assign_signal := e.assign_target_flow(lhs_id, values[idx], declare)!
            if assign_signal.kind != .normal {
                return assign_signal
            }
        }
        return normal_flow()
    }
    mut i := 0
    for i < children.len {
        lhs_id := children[i]
        rhs_id := if i + 1 < children.len { children[i + 1] } else { flat.empty_node }
        value := if int(rhs_id) >= 0 {
            target_type := e.assignment_target_type_name(lhs_id, declare)
            signal := e.assignment_value_flow(node.op, lhs_id, rhs_id, target_type)!
            if signal.kind != .normal {
                return signal
            }
            flow_value(signal)
        } else {
            void_value()
        }
        assign_signal := e.assign_target_flow(lhs_id, value, declare)!
        if assign_signal.kind != .normal {
            return assign_signal
        }
        i += 2
    }
    return normal_flow()
}

fn (e &Eval) target_needs_single_eval(id flat.NodeId) bool {
    if int(id) < 0 {
        return false
    }
    return e.node(id).kind in [.index, .selector]
}

fn (mut e Eval) exec_compound_assignment_pair_flow(op flat.Op, lhs_id flat.NodeId, rhs_id flat.NodeId, declare bool) !FlowSignal {
    target_type := e.assignment_target_type_name(lhs_id, declare)
    rhs_signal := e.eval_expr_flow_expected(rhs_id, target_type)!
    if rhs_signal.kind != .normal {
        return rhs_signal
    }
    rhs := flow_value(rhs_signal)
    return e.apply_compound_target_flow(op, lhs_id, rhs, declare, if target_type.len > 0 {
        target_type
    } else {
        e.infer_expr_type_name(rhs_id)
    })
}

fn (mut e Eval) apply_compound_target_flow(op flat.Op, lhs_id flat.NodeId, rhs Value, declare bool, type_name string) !FlowSignal {
    node := e.node(lhs_id)
    match node.kind {
        .index {
            return e.update_resolved_lvalue_with_op_flow(lhs_id, op, rhs)
        }
        .selector {
            return e.update_resolved_lvalue_with_op_flow(lhs_id, op, rhs)
        }
        else {
            left_signal := e.eval_expr_flow(lhs_id)!
            if left_signal.kind != .normal {
                return left_signal
            }
            value := e.apply_assignment_op(op, flow_value(left_signal), rhs)!
            return e.assign_target_typed_flow(lhs_id, value, declare, type_name)
        }
    }
}

fn (mut e Eval) assignment_value(op flat.Op, lhs_id flat.NodeId, rhs_id flat.NodeId) !Value {
    rhs := e.eval_expr(rhs_id)!
    if op == .assign || op == .none {
        return rhs
    }
    left := e.eval_expr(lhs_id) or { e.zero_value_like(rhs) }
    return match op {
        .plus_assign { e.apply_infix(.plus, left, rhs)! }
        .minus_assign { e.apply_infix(.minus, left, rhs)! }
        .mul_assign { e.apply_infix(.mul, left, rhs)! }
        .div_assign { e.apply_infix(.div, left, rhs)! }
        .mod_assign { e.apply_infix(.mod, left, rhs)! }
        .amp_assign { e.apply_infix(.amp, left, rhs)! }
        .pipe_assign { e.apply_infix(.pipe, left, rhs)! }
        .xor_assign { e.apply_infix(.xor, left, rhs)! }
        .left_shift_assign { e.apply_infix(.left_shift, left, rhs)! }
        .right_shift_assign { e.apply_infix(.right_shift, left, rhs)! }
        .right_shift_unsigned_assign { e.apply_infix(.right_shift_unsigned, left, rhs)! }
        else { rhs }
    }
}

fn (mut e Eval) assignment_value_flow(op flat.Op, lhs_id flat.NodeId, rhs_id flat.NodeId, expected_type string) !FlowSignal {
    rhs_signal := e.eval_expr_flow_expected(rhs_id, expected_type)!
    if rhs_signal.kind != .normal {
        return rhs_signal
    }
    rhs := flow_value(rhs_signal)
    if op == .assign || op == .none {
        return FlowSignal{
            values: [rhs]
        }
    }
    left_signal := e.eval_expr_flow(lhs_id)!
    if left_signal.kind != .normal {
        return left_signal
    }
    left := flow_value(left_signal)
    return FlowSignal{
        values: [e.apply_assignment_op(op, left, rhs)!]
    }
}

fn (mut e Eval) apply_assignment_op(op flat.Op, left Value, rhs Value) !Value {
    return match op {
        .plus_assign { e.apply_infix(.plus, left, rhs)! }
        .minus_assign { e.apply_infix(.minus, left, rhs)! }
        .mul_assign { e.apply_infix(.mul, left, rhs)! }
        .div_assign { e.apply_infix(.div, left, rhs)! }
        .mod_assign { e.apply_infix(.mod, left, rhs)! }
        .amp_assign { e.apply_infix(.amp, left, rhs)! }
        .pipe_assign { e.apply_infix(.pipe, left, rhs)! }
        .xor_assign { e.apply_infix(.xor, left, rhs)! }
        .left_shift_assign { e.apply_infix(.left_shift, left, rhs)! }
        .right_shift_assign { e.apply_infix(.right_shift, left, rhs)! }
        .right_shift_unsigned_assign { e.apply_infix(.right_shift_unsigned, left, rhs)! }
        else { rhs }
    }
}

fn (mut e Eval) assignment_target_type_name(lhs_id flat.NodeId, declare bool) string {
    if int(lhs_id) < 0 {
        return ''
    }
    node := e.node(lhs_id)
    match node.kind {
        .ident {
            if !declare {
                if typ := e.lookup_var_type(node.value) {
                    return typ
                }
            }
            return node.typ
        }
        .selector {
            if node.children_count > 0 {
                base_type := e.infer_expr_type_name(e.child(node, 0))
                if base_type.len > 0 {
                    return e.struct_field_type_name_by_type(base_type, node.value)
                }
            }
        }
        .index {
            if node.children_count > 0 {
                container_type := e.infer_expr_type_name(e.child(node, 0))
                if container_type.starts_with('[]') {
                    return container_type[2..]
                }
                if is_fixed_array_type_name(container_type) {
                    return fixed_array_elem_type_name(container_type)
                }
                if container_type.starts_with('map[') {
                    _, value_type := split_map_type(container_type)
                    return value_type
                }
            }
        }
        else {}
    }

    return ''
}

fn flow_value(signal FlowSignal) Value {
    if signal.values.len > 0 {
        return signal.values[0]
    }
    return void_value()
}

fn flow_values_value(values []Value) Value {
    if values.len == 0 {
        return void_value()
    }
    if values.len == 1 {
        return values[0]
    }
    return TupleValue{
        values: values.clone()
    }
}

fn flow_values_or_void(values []Value) []Value {
    if values.len > 0 {
        return values.clone()
    }
    return [void_value()]
}

fn (mut e Eval) assign_target(id flat.NodeId, value Value, declare bool) ! {
    signal := e.assign_target_typed_flow(id, value, declare, '')!
    if signal.kind != .normal {
        return error('v3.eval: unexpected `${signal.kind}` escaped assignment target')
    }
}

fn (mut e Eval) assign_target_typed(id flat.NodeId, value Value, declare bool, type_name string) ! {
    signal := e.assign_target_typed_flow(id, value, declare, type_name)!
    if signal.kind != .normal {
        return error('v3.eval: unexpected `${signal.kind}` escaped assignment target')
    }
}

fn (mut e Eval) assign_target_flow(id flat.NodeId, value Value, declare bool) !FlowSignal {
    return e.assign_target_typed_flow(id, value, declare, '')
}

fn (mut e Eval) assign_target_typed_flow(id flat.NodeId, value Value, declare bool, type_name string) !FlowSignal {
    node := e.node(id)
    match node.kind {
        .ident {
            if declare {
                decl_type := if type_name.len > 0 { type_name } else { node.typ }
                e.declare_var_typed(node.value, e.adapt_value_to_type_name(value, decl_type),
                    decl_type)
            } else {
                target_type := if existing := e.lookup_var_type(node.value) {
                    existing
                } else {
                    if type_name.len > 0 { type_name } else { node.typ }
                }
                e.set_var(node.value, e.adapt_value_to_type_name(value, target_type))!
                e.set_var_type(node.value, target_type)
            }
        }
        .selector {
            return e.update_resolved_lvalue_flow(id, value)
        }
        .index {
            return e.update_resolved_lvalue_flow(id, value)
        }
        else {
            return error('v3.eval: unsupported assignment target `${node.kind}`')
        }
    }

    return normal_flow()
}

fn (e &Eval) infer_expr_type_name(id flat.NodeId) string {
    if int(id) < 0 {
        return ''
    }
    node := e.node(id)
    if node.kind in [.struct_init, .cast_expr, .as_expr] {
        return e.normalize_type_name(node.value)
    }
    if node.typ.len > 0 {
        return e.normalize_type_name(node.typ)
    }
    match node.kind {
        .int_literal {
            return 'int'
        }
        .float_literal {
            return 'f64'
        }
        .bool_literal {
            return 'bool'
        }
        .char_literal {
            return 'char'
        }
        .string_literal, .string_interp {
            return 'string'
        }
        .ident {
            if typ := e.lookup_var_type(node.value) {
                return typ
            }
        }
        .selector {
            if node.children_count > 0 {
                if typ := e.type_value_name_from_expr(e.child(node, 0)) {
                    return typ
                }
                base_type := e.infer_expr_type_name(e.child(node, 0))
                if base_type.len > 0 {
                    return e.struct_field_type_name_by_type(base_type, node.value)
                }
            }
        }
        .index {
            if node.children_count > 0 {
                container_type := e.infer_expr_type_name(e.child(node, 0))
                if container_type.starts_with('[]') {
                    return container_type[2..]
                }
                if is_fixed_array_type_name(container_type) {
                    return fixed_array_elem_type_name(container_type)
                }
                if container_type.starts_with('map[') {
                    _, value_type := split_map_type(container_type)
                    return value_type
                }
            }
        }
        .array_literal {
            elem_type_name := e.array_literal_elem_type_name(node)
            if elem_type_name.len > 0 {
                return '[]${elem_type_name}'
            }
        }
        else {}
    }

    return ''
}

fn (e &Eval) array_literal_elem_type_name(node &flat.Node) string {
    if node.typ.len > 0 {
        return array_elem_type_name_from_type(node.typ)
    }
    if node.value.len > 0 {
        return array_elem_type_name_from_type(node.value)
    }
    if node.children_count > 0 {
        return e.infer_expr_type_name(e.child(node, 0))
    }
    return ''
}

fn array_elem_type_name_from_type(type_name string) string {
    if type_name.starts_with('[]') {
        return type_name[2..]
    }
    if is_fixed_array_type_name(type_name) {
        return fixed_array_elem_type_name(type_name)
    }
    return ''
}

fn (mut e Eval) update_target(id flat.NodeId, value Value) ! {
    signal := e.update_target_flow(id, value)!
    if signal.kind != .normal {
        return error('v3.eval: unexpected `${signal.kind}` escaped assignment target')
    }
}

fn (mut e Eval) update_target_flow(id flat.NodeId, value Value) !FlowSignal {
    return e.assign_target_flow(id, value, false)
}

fn (mut e Eval) update_resolved_lvalue_flow(id flat.NodeId, value Value) !FlowSignal {
    resolved := e.resolve_lvalue_flow(id)!
    if resolved.signal.kind != .normal {
        return resolved.signal
    }
    return e.write_resolved_lvalue_flow(resolved, value)
}

fn (mut e Eval) update_resolved_lvalue_with_op_flow(id flat.NodeId, op flat.Op, rhs Value) !FlowSignal {
    resolved := e.resolve_lvalue_flow(id)!
    if resolved.signal.kind != .normal {
        return resolved.signal
    }
    value := e.apply_assignment_op(op, resolved.value, rhs)!
    return e.write_resolved_lvalue_flow(resolved, value)
}

fn (mut e Eval) update_resolved_lvalue_postfix_flow(id flat.NodeId, op flat.Op) !FlowSignal {
    resolved := e.resolve_lvalue_flow(id)!
    if resolved.signal.kind != .normal {
        return resolved.signal
    }
    value := e.apply_postfix_op(op, resolved.value)!
    update_signal := e.write_resolved_lvalue_flow(resolved, value)!
    if update_signal.kind != .normal {
        return update_signal
    }
    return value_flow(resolved.value)
}

fn (mut e Eval) resolve_lvalue_flow(id flat.NodeId) !ResolvedLvalue {
    node := e.node(id)
    match node.kind {
        .selector {
            mut base := e.resolve_lvalue_flow(e.child(node, 0))!
            if base.signal.kind != .normal {
                return base
            }
            value := e.eval_selector_value(base.value, node.value)!
            base.steps << LvalueStep{
                kind:       .selector
                container:  base.value
                index:      void_value()
                field_name: node.value
            }
            base.value = value
            return base
        }
        .index {
            mut base := e.resolve_lvalue_flow(e.child(node, 0))!
            if base.signal.kind != .normal {
                return base
            }
            index_signal := if base.value is MapValue {
                e.eval_expr_flow_expected(e.child(node, 1), base.value.key_type_name)!
            } else {
                e.eval_expr_flow(e.child(node, 1))!
            }
            if index_signal.kind != .normal {
                return ResolvedLvalue{
                    signal: index_signal
                }
            }
            index := flow_value(index_signal)
            value := e.index_value(base.value, index)!
            base.steps << LvalueStep{
                kind:      .index
                container: base.value
                index:     index
            }
            base.value = value
            return base
        }
        else {
            signal := e.eval_expr_flow(id)!
            if signal.kind != .normal {
                return ResolvedLvalue{
                    signal: signal
                }
            }
            return ResolvedLvalue{
                root_id: id
                value:   flow_value(signal)
            }
        }
    }
}

fn (mut e Eval) write_resolved_lvalue_flow(resolved ResolvedLvalue, value Value) !FlowSignal {
    mut new_value := value
    for i := resolved.steps.len - 1; i >= 0; i-- {
        step := resolved.steps[i]
        match step.kind {
            .index {
                new_value = e.set_index_value(step.container, step.index, new_value)!
            }
            .selector {
                new_value = e.set_selector_value(step.container, step.field_name, new_value)!
            }
            else {}
        }
    }
    return e.update_target_flow(resolved.root_id, new_value)
}

fn (mut e Eval) set_index_value(container Value, index Value, value Value) !Value {
    match container {
        ArrayValue {
            mut arr := ArrayValue{
                elem_type_name: container.elem_type_name
                values:         container.values.clone()
            }
            idx := int(e.value_as_int(index)!)
            if idx < 0 || idx >= arr.values.len {
                return error('v3.eval: array index out of bounds')
            }
            arr.values[idx] = e.adapt_value_to_type_name(value, arr.elem_type_name)
            return arr
        }
        MapValue {
            return e.map_set_value(container, index, value)
        }
        else {
            return error('v3.eval: indexed assignment expects array or map')
        }
    }
}

fn (mut e Eval) set_selector_value(container Value, field_name string, value Value) !Value {
    match container {
        StructValue {
            mut st := container
            st.fields[field_name] = e.adapt_value_to_type_name(value, e.struct_field_type_name(container,
                field_name))
            return st
        }
        SumValue {
            mut sv := container
            sv.payload = e.set_selector_value(sv.payload, field_name, value)!
            return sv
        }
        else {
            return error('v3.eval: selector assignment expects struct, got `${e.runtime_type_name(container)}`')
        }
    }
}

fn (mut e Eval) exec_array_append(node &flat.Node) !FlowSignal {
    lhs_id := e.child(node, 0)
    rhs_id := e.child(node, 1)
    resolved := e.resolve_lvalue_flow(lhs_id)!
    if resolved.signal.kind != .normal {
        return resolved.signal
    }
    current := resolved.value
    if current !is ArrayValue {
        return error('v3.eval: `<<` is only supported for arrays')
    }
    mut arr := current as ArrayValue
    rhs_type_name := e.infer_expr_type_name(rhs_id)
    rhs_expected_type := if rhs_type_name.len > 0
        && e.array_type_spreads_into_elem(rhs_type_name, arr.elem_type_name) {
        rhs_type_name
    } else {
        arr.elem_type_name
    }
    rhs_signal := e.eval_expr_flow_expected(rhs_id, rhs_expected_type)!
    if rhs_signal.kind != .normal {
        return rhs_signal
    }
    rhs := flow_value(rhs_signal)
    if rhs is ArrayValue && e.array_append_rhs_spreads(rhs_id, rhs, arr.elem_type_name) {
        for item in rhs.values {
            arr.values << e.adapt_value_to_type_name(item, arr.elem_type_name)
        }
    } else {
        arr.values << e.adapt_value_to_type_name(rhs, arr.elem_type_name)
    }
    return e.write_resolved_lvalue_flow(resolved, arr)
}

fn (e &Eval) array_append_rhs_spreads(rhs_id flat.NodeId, rhs ArrayValue, elem_type_name string) bool {
    rhs_type_name := e.infer_expr_type_name(rhs_id)
    if rhs_type_name.len > 0 {
        return e.array_type_spreads_into_elem(rhs_type_name, elem_type_name)
    }
    if rhs.elem_type_name.len > 0 {
        return e.type_name_matches(rhs.elem_type_name, elem_type_name)
    }
    return false
}

fn (e &Eval) array_type_spreads_into_elem(array_type_name string, elem_type_name string) bool {
    rhs_elem_type_name := array_elem_type_name_from_type(array_type_name)
    if rhs_elem_type_name.len == 0 {
        return false
    }
    return e.type_name_matches(rhs_elem_type_name, elem_type_name)
}

fn (mut e Eval) exec_if(node &flat.Node) !FlowSignal {
    if node.children_count < 2 {
        return normal_flow()
    }
    cond_id := e.child(node, 0)
    cond_is_guard := e.node(cond_id).kind == .decl_assign
    if cond_is_guard {
        e.open_scope()
    }
    cond_signal := e.eval_condition_flow(cond_id)!
    if cond_signal.kind != .normal {
        if cond_is_guard {
            e.close_scope()!
        }
        return cond_signal
    }
    if e.value_as_bool(flow_value(cond_signal))! {
        mut smartcast_scope := false
        if !cond_is_guard {
            if binding := e.smartcast_binding_from_condition(cond_id) {
                e.open_scope()
                e.declare_var_typed(binding.name, binding.value, binding.type_name)
                smartcast_scope = true
            }
        }
        signal := e.exec_stmt(e.child(node, 1))!
        if smartcast_scope {
            e.close_scope()!
        }
        if cond_is_guard {
            e.close_scope()!
        }
        return signal
    }
    if cond_is_guard {
        e.close_scope()!
    }
    if node.children_count > 2 {
        return e.exec_stmt(e.child(node, 2))
    }
    return normal_flow()
}

fn (mut e Eval) smartcast_binding_from_condition(cond_id flat.NodeId) ?SmartcastBinding {
    if int(cond_id) < 0 {
        return none
    }
    node := e.node(cond_id)
    if node.kind == .paren {
        return e.smartcast_binding_from_condition(e.child(node, 0))
    }
    if node.kind == .infix && node.op == .logical_and {
        return e.smartcast_binding_from_condition(e.child(node, 0))
    }
    if node.kind != .is_expr || node.children_count == 0 {
        return none
    }
    left_id := e.child(node, 0)
    left := e.node(left_id)
    if left.kind != .ident {
        return none
    }
    found := e.lookup_var(left.value)
    if !found.found {
        return none
    }
    if value := e.smartcast_value(found.value, node.value) {
        return SmartcastBinding{
            name:      left.value
            value:     value
            type_name: e.normalize_type_name(node.value)
        }
    }
    return none
}

fn (e &Eval) smartcast_value(value Value, target_type string) ?Value {
    if value is SumValue {
        if e.type_name_matches(value.variant_name, target_type)
            || e.value_matches_type_name(value.payload, target_type) {
            return value.payload
        }
    }
    return none
}

fn (mut e Eval) eval_condition(id flat.NodeId) !bool {
    signal := e.eval_condition_flow(id)!
    return e.value_as_bool(flow_value(signal))
}

fn (mut e Eval) eval_condition_flow(id flat.NodeId) !FlowSignal {
    node := e.node(id)
    if node.kind == .decl_assign {
        rhs_id := e.child(node, 1)
        rhs_node := e.node(rhs_id)
        mut ok := false
        mut bind_value := Value(void_value())
        mut bind_type := ''
        if rhs_node.kind == .index && rhs_node.value != 'range' && rhs_node.children_count > 1 {
            container_signal := e.eval_expr_flow(e.child(rhs_node, 0))!
            if container_signal.kind != .normal {
                return container_signal
            }
            container := flow_value(container_signal)
            index_signal := if container is MapValue {
                e.eval_expr_flow_expected(e.child(rhs_node, 1), container.key_type_name)!
            } else {
                e.eval_expr_flow(e.child(rhs_node, 1))!
            }
            if index_signal.kind != .normal {
                return index_signal
            }
            if container is MapValue {
                value, found := e.map_lookup(container, flow_value(index_signal))
                ok = found
                bind_value = value
                bind_type = container.value_type_name
            } else {
                value := e.index_value(container, flow_value(index_signal))!
                ok = e.value_is_truthy(value)
                bind_value = e.unwrap_option_like(value)
                bind_type = e.guard_binding_type_name(rhs_id, value)
            }
        } else {
            rhs_signal := e.eval_expr_flow(rhs_id)!
            if rhs_signal.kind != .normal {
                return rhs_signal
            }
            value := flow_value(rhs_signal)
            ok = e.value_is_truthy(value)
            bind_value = e.unwrap_option_like(value)
            bind_type = e.guard_binding_type_name(rhs_id, value)
        }
        if ok {
            e.assign_target_typed(e.child(node, 0), bind_value, true, bind_type)!
        }
        return value_flow(Value(ok))
    }
    signal := e.eval_expr_flow(id)!
    if signal.kind != .normal {
        return signal
    }
    return value_flow(Value(e.value_as_bool(flow_value(signal))!))
}

fn (e &Eval) guard_binding_type_name(rhs_id flat.NodeId, value Value) string {
    rhs_type := e.infer_expr_type_name(rhs_id)
    name := rhs_type.trim_left('&')
    if name.starts_with('?') || name.starts_with('!') {
        return name[1..]
    }
    if name.len > 0 {
        return name
    }
    return e.runtime_type_name(e.unwrap_option_like(value))
}

fn (e &Eval) unwrap_option_like(value Value) Value {
    if value is StructValue {
        if 'data' in value.fields {
            return value.fields['data'] or { void_value() }
        }
    }
    return value
}

fn (e &Eval) value_is_truthy(value Value) bool {
    match value {
        bool {
            return value
        }
        VoidValue {
            return false
        }
        StructValue {
            state := value.fields['state'] or { void_value() }
            if state is i64 {
                return state == 0
            }
            is_error := value.fields['is_error'] or { void_value() }
            if is_error is bool {
                return !is_error
            }
            return true
        }
        else {
            return true
        }
    }
}

fn (mut e Eval) exec_for(node &flat.Node, loop_label string) !FlowSignal {
    if node.children_count < 3 {
        return normal_flow()
    }
    init_id := e.child(node, 0)
    cond_id := e.child(node, 1)
    post_id := e.child(node, 2)
    e.open_scope()
    if int(init_id) >= 0 && e.node(init_id).kind != .empty {
        init_signal := e.exec_stmt(init_id)!
        if init_signal.kind != .normal {
            e.close_scope()!
            return init_signal
        }
    }
    body := e.children(node)
    for {
        if int(cond_id) >= 0 && e.node(cond_id).kind != .empty {
            cond_signal := e.eval_condition_flow(cond_id)!
            if cond_signal.kind != .normal {
                e.close_scope()!
                return cond_signal
            }
            if !e.value_as_bool(flow_value(cond_signal))! {
                break
            }
        }
        e.open_scope()
        signal := e.exec_stmts(body[3..])!
        e.close_scope()!
        if signal.kind == .break_ {
            if e.flow_targets_loop(signal, loop_label) {
                e.close_scope()!
                return normal_flow()
            }
            e.close_scope()!
            return signal
        }
        if signal.kind == .continue_ {
            if !e.flow_targets_loop(signal, loop_label) {
                e.close_scope()!
                return signal
            }
        }
        if signal.kind == .return_ {
            e.close_scope()!
            return signal
        }
        if int(post_id) >= 0 && e.node(post_id).kind != .empty {
            post_signal := e.exec_stmt(post_id)!
            if post_signal.kind != .normal {
                e.close_scope()!
                return post_signal
            }
        }
    }
    e.close_scope()!
    return normal_flow()
}

fn (mut e Eval) exec_for_in(node &flat.Node, loop_label string) !FlowSignal {
    header_count := if node.value.int() > 0 { node.value.int() } else { 3 }
    key_id := e.child(node, 0)
    val_id := e.child(node, 1)
    container_id := e.child(node, 2)
    is_mut_loop := node.op == .amp
    mut resolved_container := ResolvedLvalue{}
    mut has_resolved_container := false
    mut container := Value(void_value())
    if is_mut_loop && e.is_assignable_target(container_id) {
        resolved_container = e.resolve_lvalue_flow(container_id)!
        if resolved_container.signal.kind != .normal {
            return resolved_container.signal
        }
        container = resolved_container.value
        has_resolved_container = true
    } else {
        container_signal := e.eval_expr_flow(container_id)!
        if container_signal.kind != .normal {
            return container_signal
        }
        container = flow_value(container_signal)
    }
    body := e.children(node)[header_count..]
    if header_count == 4 {
        start := e.value_as_int(container)!
        end_signal := e.eval_expr_flow(e.child(node, 3))!
        if end_signal.kind != .normal {
            return end_signal
        }
        end := e.value_as_int(flow_value(end_signal))!
        for i := start; i < end; i++ {
            e.open_scope()
            e.assign_loop_vars(key_id, val_id, Value(i), void_value(), false)
            signal := e.exec_stmts(body)!
            e.close_scope()!
            if signal.kind == .break_ {
                if e.flow_targets_loop(signal, loop_label) {
                    return normal_flow()
                }
                return signal
            }
            if signal.kind == .continue_ {
                if e.flow_targets_loop(signal, loop_label) {
                    continue
                }
                return signal
            }
            if signal.kind == .return_ {
                return signal
            }
        }
        return normal_flow()
    }
    match container {
        RangeValue {
            last := if container.inclusive { container.end + 1 } else { container.end }
            for i := container.start; i < last; i++ {
                e.open_scope()
                e.assign_loop_vars(key_id, val_id, Value(i), void_value(), false)
                signal := e.exec_stmts(body)!
                e.close_scope()!
                if signal.kind == .break_ {
                    if e.flow_targets_loop(signal, loop_label) {
                        return normal_flow()
                    }
                    return signal
                }
                if signal.kind == .continue_ {
                    if e.flow_targets_loop(signal, loop_label) {
                        continue
                    }
                    return signal
                }
                if signal.kind == .return_ {
                    return signal
                }
            }
        }
        ArrayValue {
            mut arr := ArrayValue{
                elem_type_name: container.elem_type_name
                values:         container.values.clone()
            }
            for i, item in arr.values {
                e.open_scope()
                e.assign_loop_vars(key_id, val_id, Value(i64(i)), item, true)
                signal := e.exec_stmts(body)!
                if is_mut_loop {
                    if value := e.loop_mut_value(key_id, val_id, true) {
                        arr.values[i] = e.adapt_value_to_type_name(value, arr.elem_type_name)
                        mut write_signal := FlowSignal{}
                        if has_resolved_container {
                            write_signal = e.write_resolved_lvalue_flow(resolved_container, arr) or {
                                e.close_scope()!
                                return err
                            }
                        } else {
                            write_signal = e.update_target_flow(container_id, arr) or {
                                e.close_scope()!
                                return err
                            }
                        }
                        if write_signal.kind != .normal {
                            e.close_scope()!
                            return write_signal
                        }
                    }
                }
                e.close_scope()!
                if signal.kind == .break_ {
                    if e.flow_targets_loop(signal, loop_label) {
                        return normal_flow()
                    }
                    return signal
                }
                if signal.kind == .continue_ {
                    if e.flow_targets_loop(signal, loop_label) {
                        continue
                    }
                    return signal
                }
                if signal.kind == .return_ {
                    return signal
                }
            }
        }
        MapValue {
            mut m := MapValue{
                key_type_name:   container.key_type_name
                value_type_name: container.value_type_name
                default_value:   container.default_value
                entries:         container.entries.clone()
            }
            for i, entry in m.entries {
                e.open_scope()
                e.assign_loop_vars(key_id, val_id, entry.key, entry.value, true)
                signal := e.exec_stmts(body)!
                if is_mut_loop {
                    if value := e.loop_mut_value(key_id, val_id, true) {
                        m.entries[i].value = e.adapt_value_to_type_name(value, m.value_type_name)
                        mut write_signal := FlowSignal{}
                        if has_resolved_container {
                            write_signal = e.write_resolved_lvalue_flow(resolved_container, m) or {
                                e.close_scope()!
                                return err
                            }
                        } else {
                            write_signal = e.update_target_flow(container_id, m) or {
                                e.close_scope()!
                                return err
                            }
                        }
                        if write_signal.kind != .normal {
                            e.close_scope()!
                            return write_signal
                        }
                    }
                }
                e.close_scope()!
                if signal.kind == .break_ {
                    if e.flow_targets_loop(signal, loop_label) {
                        return normal_flow()
                    }
                    return signal
                }
                if signal.kind == .continue_ {
                    if e.flow_targets_loop(signal, loop_label) {
                        continue
                    }
                    return signal
                }
                if signal.kind == .return_ {
                    return signal
                }
            }
        }
        string {
            for i, ch in container {
                e.open_scope()
                e.assign_loop_vars(key_id, val_id, Value(i64(i)), Value(i64(ch)), true)
                signal := e.exec_stmts(body)!
                e.close_scope()!
                if signal.kind == .break_ {
                    if e.flow_targets_loop(signal, loop_label) {
                        return normal_flow()
                    }
                    return signal
                }
                if signal.kind == .continue_ {
                    if e.flow_targets_loop(signal, loop_label) {
                        continue
                    }
                    return signal
                }
                if signal.kind == .return_ {
                    return signal
                }
            }
        }
        else {
            return error('v3.eval: unsupported for-in iterable `${e.runtime_type_name(container)}`')
        }
    }

    return normal_flow()
}

fn (e &Eval) flow_targets_loop(signal FlowSignal, loop_label string) bool {
    return signal.label.len == 0 || signal.label == loop_label
}

fn (mut e Eval) assign_loop_vars(key_id flat.NodeId, val_id flat.NodeId, key Value, value Value, has_value bool) {
    if int(val_id) >= 0 && e.node(val_id).kind != .empty {
        e.assign_target(key_id, key, true) or {}
        e.assign_target(val_id, value, true) or {}
    } else if has_value {
        e.assign_target(key_id, value, true) or {}
    } else {
        e.assign_target(key_id, key, true) or {}
    }
}

fn (e &Eval) loop_mut_value(key_id flat.NodeId, val_id flat.NodeId, has_value bool) ?Value {
    mut value_id := key_id
    if int(val_id) >= 0 && e.node(val_id).kind != .empty {
        value_id = val_id
    } else if !has_value {
        return none
    }
    value_node := e.node(value_id)
    if value_node.kind != .ident {
        return none
    }
    found := e.lookup_var(value_node.value)
    if !found.found {
        return none
    }
    return found.value
}

fn (mut e Eval) eval_expr(id flat.NodeId) !Value {
    if int(id) < 0 {
        return void_value()
    }
    node := e.node(id)
    match node.kind {
        .empty {
            return void_value()
        }
        .int_literal {
            return Value(strconv.parse_int(clean_number_literal(node.value), 0, 64) or { i64(0) })
        }
        .float_literal {
            return Value(strconv.atof64(clean_number_literal(node.value)) or { 0.0 })
        }
        .bool_literal {
            return Value(node.value == 'true')
        }
        .char_literal {
            return Value(e.char_literal_value(node.value))
        }
        .string_literal {
            return Value(node.value)
        }
        .string_interp {
            return flow_value(e.eval_string_interp_flow(node)!)
        }
        .ident {
            return e.eval_ident(node.value)
        }
        .enum_val {
            return e.lookup_const(e.current_module_name(), node.value) or { Value(i64(0)) }
        }
        .paren {
            return e.eval_expr(e.child(node, 0))
        }
        .prefix {
            return e.eval_prefix(node)
        }
        .postfix {
            return e.eval_postfix(node)
        }
        .infix {
            if node.op == .logical_and {
                left := e.eval_expr(e.child(node, 0))!
                if !e.value_as_bool(left)! {
                    return Value(false)
                }
                return Value(e.value_as_bool(e.eval_expr(e.child(node, 1))!)!)
            }
            if node.op == .logical_or {
                left := e.eval_expr(e.child(node, 0))!
                if e.value_as_bool(left)! {
                    return Value(true)
                }
                return Value(e.value_as_bool(e.eval_expr(e.child(node, 1))!)!)
            }
            return e.apply_infix(node.op, e.eval_expr(e.child(node, 0))!, e.eval_expr(e.child(node,
                1))!)
        }
        .call {
            return flow_value(e.eval_call_flow(id, node)!)
        }
        .selector {
            return e.eval_selector(node)
        }
        .index {
            return e.eval_index(node)
        }
        .if_expr {
            return e.eval_if_value(node)
        }
        .block {
            return e.eval_block_value(node)
        }
        .array_literal {
            mut values := []Value{}
            elem_type_name := e.array_literal_elem_type_name(node)
            for child_id in e.children(node) {
                values << e.adapt_value_to_type_name(e.eval_expr_expected(child_id, elem_type_name)!,
                    elem_type_name)
            }
            return ArrayValue{
                elem_type_name: elem_type_name
                values:         values
            }
        }
        .array_init {
            return e.eval_array_init(node)
        }
        .map_init {
            return flow_value(e.eval_map_init_flow(node)!)
        }
        .struct_init {
            return e.eval_struct_init(node)
        }
        .assoc {
            return e.eval_assoc(node)
        }
        .range {
            return RangeValue{
                start: e.value_as_int(e.eval_expr(e.child(node, 0))!)!
                end:   e.value_as_int(e.eval_expr(e.child(node, 1))!)!
            }
        }
        .cast_expr, .as_expr {
            value := e.eval_expr(e.child(node, 0))!
            return e.cast_value(value, node.value)
        }
        .is_expr {
            value := e.eval_expr(e.child(node, 0))!
            return Value(e.value_matches_type_name(value, node.value))
        }
        .in_expr {
            left := e.eval_expr(e.child(node, 0))!
            right := e.eval_expr(e.child(node, 1))!
            return Value(e.value_in(left, right))
        }
        .or_expr {
            return e.eval_or_expr(node)
        }
        .match_stmt {
            return e.eval_match_value(node)
        }
        .none_expr, .nil_literal {
            return void_value()
        }
        .sizeof_expr {
            return Value(e.sizeof_type_name(node.value))
        }
        .typeof_expr {
            value := e.eval_expr(e.child(node, 0))!
            return TypeValue{
                name: e.runtime_type_name(value)
            }
        }
        .fn_literal {
            return Value(e.eval_fn_literal(id, node)!)
        }
        else {
            return error('v3.eval: unsupported expression `${node.kind}`')
        }
    }
}

fn (mut e Eval) eval_fn_literal(id flat.NodeId, node &flat.Node) !FnValue {
    mut captures := map[string]Value{}
    mut capture_types := map[string]string{}
    for child_id in e.children(node) {
        child := e.node(child_id)
        if child.kind != .ident {
            break
        }
        found := e.lookup_var(child.value)
        if !found.found {
            return error('v3.eval: unknown captured variable `${child.value}`')
        }
        captures[child.value] = found.value
        if typ := e.lookup_var_type(child.value) {
            capture_types[child.value] = typ
        }
    }
    return FnValue{
        node:          id
        module_name:   e.current_module_name()
        file_name:     e.current_file_name()
        captures:      captures
        capture_types: capture_types
    }
}

fn (mut e Eval) eval_expr_flow(id flat.NodeId) !FlowSignal {
    if int(id) < 0 {
        return FlowSignal{
            values: [void_value()]
        }
    }
    node := e.node(id)
    match node.kind {
        .or_expr {
            return e.eval_or_expr_flow(node)
        }
        .call {
            return e.eval_call_flow(id, node)
        }
        .index {
            return e.eval_index_flow(node)
        }
        .if_expr {
            return e.eval_if_value_flow(node)
        }
        .match_stmt {
            return e.eval_match_value_flow(node)
        }
        .selector {
            left_signal := e.eval_expr_flow(e.child(node, 0))!
            if left_signal.kind != .normal {
                return left_signal
            }
            return value_flow(e.eval_selector_value(flow_value(left_signal), node.value)!)
        }
        .paren {
            return e.eval_expr_flow(e.child(node, 0))
        }
        .prefix {
            value_signal := e.eval_expr_flow(e.child(node, 0))!
            if value_signal.kind != .normal {
                return value_signal
            }
            return value_flow(e.apply_prefix(node.op, flow_value(value_signal))!)
        }
        .postfix {
            return e.eval_postfix_flow(node)
        }
        .infix {
            return e.eval_infix_flow(node)
        }
        .range {
            start_signal := e.eval_expr_flow(e.child(node, 0))!
            if start_signal.kind != .normal {
                return start_signal
            }
            end_signal := e.eval_expr_flow(e.child(node, 1))!
            if end_signal.kind != .normal {
                return end_signal
            }
            return value_flow(RangeValue{
                start: e.value_as_int(flow_value(start_signal))!
                end:   e.value_as_int(flow_value(end_signal))!
            })
        }
        .cast_expr, .as_expr {
            value_signal := e.eval_expr_flow(e.child(node, 0))!
            if value_signal.kind != .normal {
                return value_signal
            }
            return value_flow(e.cast_value(flow_value(value_signal), node.value)!)
        }
        .is_expr {
            value_signal := e.eval_expr_flow(e.child(node, 0))!
            if value_signal.kind != .normal {
                return value_signal
            }
            return value_flow(Value(e.value_matches_type_name(flow_value(value_signal), node.value)))
        }
        .in_expr {
            left_signal := e.eval_expr_flow(e.child(node, 0))!
            if left_signal.kind != .normal {
                return left_signal
            }
            right_signal := e.eval_expr_flow(e.child(node, 1))!
            if right_signal.kind != .normal {
                return right_signal
            }
            return value_flow(Value(e.value_in(flow_value(left_signal), flow_value(right_signal))))
        }
        .array_literal {
            mut values := []Value{}
            elem_type_name := e.array_literal_elem_type_name(node)
            for child_id in e.children(node) {
                child_signal := e.eval_expr_flow_expected(child_id, elem_type_name)!
                if child_signal.kind != .normal {
                    return child_signal
                }
                values << e.adapt_value_to_type_name(flow_value(child_signal), elem_type_name)
            }
            return value_flow(ArrayValue{
                elem_type_name: elem_type_name
                values:         values
            })
        }
        .array_init {
            return e.eval_array_init_flow(node)
        }
        .struct_init {
            return e.eval_struct_init_flow(node)
        }
        .map_init {
            return e.eval_map_init_flow(node)
        }
        .assoc {
            return e.eval_assoc_flow(node)
        }
        .string_interp {
            return e.eval_string_interp_flow(node)
        }
        else {
            return FlowSignal{
                values: [e.eval_expr(id)!]
            }
        }
    }
}

fn (mut e Eval) eval_expr_expected(id flat.NodeId, expected_type string) !Value {
    signal := e.eval_expr_flow_expected(id, expected_type)!
    if signal.kind != .normal {
        return flow_value(signal)
    }
    return flow_value(signal)
}

fn (mut e Eval) eval_expr_flow_expected(id flat.NodeId, expected_type string) !FlowSignal {
    if int(id) >= 0 {
        node := e.node(id)
        if node.kind == .enum_val && expected_type.len > 0 {
            if value := e.lookup_enum_value(expected_type, node.value) {
                return value_flow(value)
            }
        }
        if expected_type.len > 0 {
            match node.kind {
                .if_expr {
                    return e.eval_if_value_flow_expected(node, expected_type)
                }
                .match_stmt {
                    return e.eval_match_value_flow_expected(node, expected_type)
                }
                .block {
                    return e.eval_block_value_flow_expected(node, expected_type)
                }
                .paren {
                    return e.eval_expr_flow_expected(e.child(node, 0), expected_type)
                }
                else {}
            }
        }
    }
    return e.eval_expr_flow(id)
}

fn (e &Eval) current_return_type() string {
    if e.call_stack.len == 0 {
        return ''
    }
    return e.call_stack[e.call_stack.len - 1].return_type
}

fn return_child_expected_type(return_type string, return_types []string, child_index int, child_count int) string {
    if return_types.len > 0 {
        if child_count == return_types.len && child_index < return_types.len {
            return return_types[child_index]
        }
        return ''
    }
    if child_count == 1 {
        return return_type
    }
    return ''
}

fn (mut e Eval) eval_infix_flow(node &flat.Node) !FlowSignal {
    left_signal := e.eval_expr_flow(e.child(node, 0))!
    if left_signal.kind != .normal {
        return left_signal
    }
    left := flow_value(left_signal)
    if node.op == .logical_and {
        if !e.value_as_bool(left)! {
            return value_flow(Value(false))
        }
        mut smartcast_scope := false
        if binding := e.smartcast_binding_from_condition(e.child(node, 0)) {
            e.open_scope()
            e.declare_var_typed(binding.name, binding.value, binding.type_name)
            smartcast_scope = true
        }
        right_signal := e.eval_expr_flow(e.child(node, 1))!
        if smartcast_scope {
            e.close_scope()!
        }
        if right_signal.kind != .normal {
            return right_signal
        }
        return value_flow(Value(e.value_as_bool(flow_value(right_signal))!))
    }
    if node.op == .logical_or {
        if e.value_as_bool(left)! {
            return value_flow(Value(true))
        }
        right_signal := e.eval_expr_flow(e.child(node, 1))!
        if right_signal.kind != .normal {
            return right_signal
        }
        return value_flow(Value(e.value_as_bool(flow_value(right_signal))!))
    }
    right_signal := e.eval_expr_flow(e.child(node, 1))!
    if right_signal.kind != .normal {
        return right_signal
    }
    return value_flow(e.apply_infix(node.op, left, flow_value(right_signal))!)
}

fn clean_number_literal(value string) string {
    return value.replace('_', '')
}

fn (e &Eval) char_literal_value(raw string) i64 {
    mut s := raw
    if s.len >= 2 && ((s[0] == `'` && s[s.len - 1] == `'`)
        || (s[0] == `\`` && s[s.len - 1] == `\``)) {
        s = s[1..s.len - 1]
    }
    if s.len == 0 {
        return 0
    }
    if s.len >= 2 && s[0] == `\\` {
        return match s[1] {
            `n` { i64(`\n`) }
            `t` { i64(`\t`) }
            `r` { i64(`\r`) }
            `\\` { i64(`\\`) }
            `'` { i64(`'`) }
            `"` { i64(`"`) }
            `$` { i64(`$`) }
            `0` { i64(0) }
            `a` { i64(7) }
            `b` { i64(8) }
            `f` { i64(12) }
            `v` { i64(11) }
            else { i64(s[0]) }
        }
    }
    return i64(s[0])
}

fn (mut e Eval) eval_ident(name string) !Value {
    if name == '_' {
        return void_value()
    }
    found := e.lookup_var(name)
    if found.found {
        return found.value
    }
    if value := e.lookup_const(e.current_module_name(), name) {
        return value
    }
    mod_name := e.resolve_module_name(name)
    if mod_name in e.modules || name in ['os', 'time', 'strings'] {
        return ModuleValue{
            name: mod_name
        }
    }
    if e.has_type_name(e.current_module_name(), name) {
        return TypeValue{
            name: e.qualify_type_name(e.current_module_name(), name)
        }
    }
    return e.unknown_variable_error(name)
}

fn (e &Eval) resolve_module_name(name string) string {
    file_name := e.current_file_name()
    if file_name in e.file_import_alias {
        aliases := e.file_import_alias[file_name].clone()
        if name in aliases {
            return aliases[name]
        }
    }
    return name
}

fn (e &Eval) has_type_name(module_name string, name string) bool {
    if module_name in e.type_names && name in e.type_names[module_name] {
        return true
    }
    if name.contains('.') {
        mod := name.all_before_last('.')
        short := name.all_after_last('.')
        return mod in e.type_names && short in e.type_names[mod]
    }
    return name in e.structs || name in e.sum_types
}

fn (mut e Eval) lookup_const(module_name string, name string) ?Value {
    if module_name in e.consts && name in e.consts[module_name] {
        mut entry := e.consts[module_name][name]
        if entry.cached {
            return entry.value
        }
        if entry.evaluating {
            return none
        }
        entry.evaluating = true
        e.consts[module_name][name] = entry
        mut value := Value(void_value())
        if e.node(entry.node).children_count > 0 {
            e.call_stack << CallFrame{
                module_name: entry.module_name
                file_name:   entry.file_name
                fn_name:     '<const ${name}>'
            }
            value = e.eval_expr(e.child(e.node(entry.node), 0)) or {
                e.call_stack.delete(e.call_stack.len - 1)
                entry.evaluating = false
                e.consts[module_name][name] = entry
                return none
            }
            e.call_stack.delete(e.call_stack.len - 1)
        }
        entry.cached = true
        entry.evaluating = false
        entry.value = value
        e.consts[module_name][name] = entry
        return value
    }
    for mod_name in e.consts.keys() {
        if name in e.consts[mod_name] {
            return e.lookup_const(mod_name, name)
        }
    }
    return none
}

fn (mut e Eval) eval_call_flow(id flat.NodeId, node &flat.Node) !FlowSignal {
    if node.children_count == 0 {
        return FlowSignal{
            values: [void_value()]
        }
    }
    callee_id := e.child(node, 0)
    callee := e.node(callee_id)
    if value := e.disabled_call_value(node, callee) {
        return FlowSignal{
            values: [value]
        }
    }
    if callee.kind == .ident {
        fn_name := callee.value
        found := e.lookup_var(fn_name)
        if found.found && found.value is FnValue {
            fv := found.value as FnValue
            args_signal := e.eval_call_arg_values(node, e.fn_value_param_type_names(fv))!
            if args_signal.kind != .normal {
                return args_signal
            }
            result := e.call_fn_value(fv, args_signal.values)!
            e.write_back_fn_value(callee_id, result)!
            e.write_back_mutated_arg_values(node, result.mutated_args, args_signal.mut_lvalues)!
            return FlowSignal{
                values: [e.call_result_value(result)]
            }
        }
        expected_types := if target := e.function_def(e.current_module_name(), fn_name) {
            e.function_param_type_names(target, 0)
        } else {
            []string{}
        }
        args_signal := e.eval_call_arg_values(node, expected_types)!
        if args_signal.kind != .normal {
            return args_signal
        }
        result := e.call_function(e.current_module_name(), fn_name, args_signal.values)!
        e.write_back_mutated_args(node, result, args_signal.mut_lvalues)!
        return FlowSignal{
            values: [e.call_result_value(result)]
        }
    }
    if callee.kind == .selector {
        receiver_id := e.child(callee, 0)
        receiver_resolved := e.resolve_lvalue_flow(receiver_id)!
        if receiver_resolved.signal.kind != .normal {
            return receiver_resolved.signal
        }
        left := receiver_resolved.value
        if left is ModuleValue {
            expected_types := if target := e.function_def(left.name, callee.value) {
                e.function_param_type_names(target, 0)
            } else {
                []string{}
            }
            args_signal := e.eval_call_arg_values(node, expected_types)!
            if args_signal.kind != .normal {
                return args_signal
            }
            result := e.call_function(left.name, callee.value, args_signal.values)!
            e.write_back_mutated_args(node, result, args_signal.mut_lvalues)!
            return FlowSignal{
                values: [e.call_result_value(result)]
            }
        }
        if left is TypeValue {
            static_name := '${left.name.all_after_last('.')}.${callee.value}'
            static_module := e.type_value_module_name(left)
            expected_types := if target := e.function_def(static_module, static_name) {
                e.function_param_type_names(target, 0)
            } else {
                []string{}
            }
            args_signal := e.eval_call_arg_values(node, expected_types)!
            if args_signal.kind != .normal {
                return args_signal
            }
            result := e.call_function(static_module, static_name, args_signal.values)!
            e.write_back_mutated_args(node, result, args_signal.mut_lvalues)!
            return FlowSignal{
                values: [e.call_result_value(result)]
            }
        }
        selector_value := e.eval_selector_value(left, callee.value) or { void_value() }
        if selector_value is FnValue {
            args_signal :=
                e.eval_call_arg_values(node, e.fn_value_param_type_names(selector_value))!
            if args_signal.kind != .normal {
                return args_signal
            }
            result := e.call_fn_value(selector_value, args_signal.values)!
            e.write_back_fn_value(callee_id, result)!
            e.write_back_mutated_arg_values(node, result.mutated_args, args_signal.mut_lvalues)!
            return FlowSignal{
                values: [e.call_result_value(result)]
            }
        }
        receiver_type_name := e.infer_expr_type_name(receiver_id)
        expected_types := e.method_call_param_type_names(left, receiver_type_name, callee.value)
        args_signal := e.eval_call_arg_values(node, expected_types)!
        if args_signal.kind != .normal {
            return args_signal
        }
        result := e.call_value_method(left, receiver_type_name, callee.value, args_signal.values)!
        if result.receiver_changed {
            if e.is_assignable_target(receiver_id) {
                write_signal := e.write_resolved_lvalue_flow(receiver_resolved, result.receiver)!
                if write_signal.kind != .normal {
                    return write_signal
                }
            }
        }
        e.write_back_mutated_arg_values(node, result.mutated_args, args_signal.mut_lvalues)!
        return FlowSignal{
            values: [result.value]
        }
    }
    if callee.kind == .fn_literal {
        fv := e.eval_fn_literal(callee_id, callee)!
        args_signal := e.eval_call_arg_values(node, e.fn_literal_param_type_names(callee))!
        if args_signal.kind != .normal {
            return args_signal
        }
        result := e.call_fn_value(fv, args_signal.values)!
        e.write_back_mutated_arg_values(node, result.mutated_args, args_signal.mut_lvalues)!
        return FlowSignal{
            values: [e.call_result_value(result)]
        }
    }
    value := e.eval_expr(callee_id)!
    if value is FnValue {
        args_signal := e.eval_call_arg_values(node, e.fn_value_param_type_names(value))!
        if args_signal.kind != .normal {
            return args_signal
        }
        result := e.call_fn_value(value, args_signal.values)!
        e.write_back_fn_value(callee_id, result)!
        e.write_back_mutated_arg_values(node, result.mutated_args, args_signal.mut_lvalues)!
        return FlowSignal{
            values: [e.call_result_value(result)]
        }
    }
    _ = id
    return error('v3.eval: unsupported call target `${callee.kind}`')
}

fn (mut e Eval) disabled_call_value(call_node &flat.Node, callee &flat.Node) ?Value {
    match callee.kind {
        .ident {
            found := e.lookup_var(callee.value)
            if found.found && found.value is FnValue {
                return none
            }
            if value := e.disabled_function_zero_value(e.current_module_name(), callee.value,
                call_node)
            {
                return value
            }
        }
        .selector {
            if callee.children_count == 0 {
                return none
            }
            base_id := e.child(callee, 0)
            base := e.node(base_id)
            receiver_type := e.infer_expr_type_name(base_id)
            if receiver_type.len > 0 {
                if target := e.resolve_method_target(receiver_type, callee.value) {
                    if e.is_disabled_fn_name_in_module(target.module_name, target.name) {
                        return e.zero_value_for_disabled_function(call_node, target)
                    }
                }
            }
            if base.kind == .ident {
                full_name := '${base.value}.${callee.value}'
                if value := e.disabled_function_zero_value(e.current_module_name(), full_name,
                    call_node)
                {
                    return value
                }
                found := e.lookup_var(base.value)
                if !found.found {
                    module_name := e.resolve_module_name(base.value)
                    if value := e.disabled_function_zero_value(module_name, callee.value, call_node) {
                        return value
                    }
                }
            }
        }
        else {}
    }

    return none
}

fn (e &Eval) function_def(module_name string, fn_name string) ?FunctionDef {
    target_module := if module_name == '' { e.current_module_name() } else { module_name }
    if target_module !in e.functions {
        return none
    }
    if fn_name in e.functions[target_module] {
        return e.functions[target_module][fn_name]
    }
    if target_module !in ['main', 'builtin'] && !fn_name.contains('.') {
        qualified := '${target_module}.${fn_name}'
        if qualified in e.functions[target_module] {
            return e.functions[target_module][qualified]
        }
    }
    return none
}

fn (e &Eval) function_param_type_names(def FunctionDef, skip int) []string {
    node := e.node(def.node)
    mut types := []string{}
    mut param_index := 0
    for child_id in e.children(node) {
        child := e.node(child_id)
        if child.kind != .param {
            break
        }
        if param_index >= skip {
            types << e.qualify_expected_type_name(def.module_name, child.typ)
        }
        param_index++
    }
    return types
}

fn (e &Eval) qualify_expected_type_name(module_name string, type_name string) string {
    name := type_name.trim_space()
    if name == '' {
        return ''
    }
    if name.starts_with('&') {
        return '&${e.qualify_expected_type_name(module_name, name[1..])}'
    }
    if name.starts_with('...') {
        return '...${e.qualify_expected_type_name(module_name, name[3..])}'
    }
    if name.starts_with('mut ') {
        return '&${e.qualify_expected_type_name(module_name, name[4..])}'
    }
    return e.qualify_nested_type_name(module_name, name)
}

fn (e &Eval) fn_value_param_type_names(fv FnValue) []string {
    return e.fn_literal_param_type_names_in_module(e.node(fv.node), fv.module_name)
}

fn (e &Eval) fn_literal_param_type_names(node &flat.Node) []string {
    return e.fn_literal_param_type_names_in_module(node, e.current_module_name())
}

fn (e &Eval) fn_literal_param_type_names_in_module(node &flat.Node, module_name string) []string {
    children := e.children(node)
    mut i := 0
    for i < children.len {
        child := e.node(children[i])
        if child.kind != .ident {
            break
        }
        i++
    }
    mut types := []string{}
    for i < children.len {
        child := e.node(children[i])
        if child.kind != .param {
            break
        }
        types << e.qualify_expected_type_name(module_name, child.typ)
        i++
    }
    return types
}

fn (e &Eval) method_call_param_type_names(receiver Value, receiver_type_name string, method_name string) []string {
    static_type_name := e.normalize_type_name(receiver_type_name)
    if static_type_name.len > 0 {
        if target := e.resolve_method_target(static_type_name, method_name) {
            return e.function_param_type_names(target, 1)
        }
    }
    if receiver is StructValue {
        if target := e.resolve_method_target(receiver.type_name, method_name) {
            return e.function_param_type_names(target, 1)
        }
    }
    if receiver is ArrayValue {
        return e.array_method_param_type_names(receiver, method_name)
    }
    if receiver is MapValue {
        return e.map_method_param_type_names(receiver, method_name)
    }
    if receiver is SumValue {
        return e.method_call_param_type_names(receiver.payload, receiver.variant_name, method_name)
    }
    return []string{}
}

fn (e &Eval) array_method_param_type_names(receiver ArrayValue, method_name string) []string {
    return match method_name {
        'contains', 'index' { [receiver.elem_type_name] }
        else { []string{} }
    }
}

fn (e &Eval) map_method_param_type_names(receiver MapValue, method_name string) []string {
    return match method_name {
        'delete' { [receiver.key_type_name] }
        else { []string{} }
    }
}

fn (mut e Eval) eval_call_arg_values(node &flat.Node, expected_types []string) !FlowSignal {
    mut args := []Value{}
    mut mut_lvalues := map[int]ResolvedLvalue{}
    for child_index in 1 .. node.children_count {
        arg_index := child_index - 1
        expected_type := call_arg_expected_type(expected_types, arg_index)
        value_expected_type := call_arg_value_expected_type(expected_type)
        arg_id := e.child(node, child_index)
        if expected_type.starts_with('&') && e.is_assignable_target(arg_id) {
            resolved := e.resolve_lvalue_flow(arg_id)!
            if resolved.signal.kind != .normal {
                return resolved.signal
            }
            args << resolved.value
            mut_lvalues[arg_index] = resolved
            continue
        }
        signal := e.eval_expr_flow_expected(arg_id, value_expected_type)!
        if signal.kind != .normal {
            return signal
        }
        args << flow_value(signal)
    }
    return FlowSignal{
        values:      args
        mut_lvalues: mut_lvalues
    }
}

fn call_arg_expected_type(expected_types []string, index int) string {
    if index < expected_types.len {
        typ := expected_types[index]
        if typ.starts_with('...') {
            return typ[3..]
        }
        return typ
    }
    if expected_types.len > 0 {
        last := expected_types[expected_types.len - 1]
        if last.starts_with('...') {
            return last[3..]
        }
    }
    return ''
}

fn call_arg_value_expected_type(type_name string) string {
    name := type_name.trim_space()
    if name.starts_with('&') {
        return call_arg_value_expected_type(name[1..])
    }
    if name.starts_with('mut ') {
        return call_arg_value_expected_type(name[4..])
    }
    if name.starts_with('...') {
        return call_arg_value_expected_type(name[3..])
    }
    return name
}

fn (mut e Eval) disabled_function_zero_value(module_name string, fn_name string, call_node &flat.Node) ?Value {
    target_module := if module_name == '' { e.current_module_name() } else { module_name }
    mut candidates := []string{cap: 3}
    candidates << fn_name
    if target_module.len > 0 && target_module !in ['main', 'builtin'] && !fn_name.contains('.') {
        candidates << '${target_module}.${fn_name}'
    }
    if target_module in e.functions {
        for candidate in candidates {
            if candidate in e.functions[target_module] {
                target := e.functions[target_module][candidate]
                if e.is_disabled_fn_name_in_module(target.module_name, target.name)
                    || e.is_disabled_fn_name_in_module(target_module, candidate) {
                    return e.zero_value_for_disabled_function(call_node, target)
                }
            }
        }
    }
    for candidate in candidates {
        if e.is_disabled_fn_name_in_module(target_module, candidate) {
            return e.zero_value_for_disabled_return_type(call_node.typ, target_module)
        }
    }
    return none
}

fn (mut e Eval) zero_value_for_disabled_function(call_node &flat.Node, target FunctionDef) Value {
    target_node := e.node(target.node)
    return e.zero_value_for_disabled_return_type(if call_node.typ.len > 0 {
        call_node.typ
    } else {
        target_node.typ
    }, target.module_name)
}

fn (mut e Eval) zero_value_for_disabled_return_type(return_type string, module_name string) Value {
    if return_type.len == 0 || return_type == 'void' {
        return void_value()
    }
    return e.zero_value_for_type_name_in_module(return_type, module_name)
}

fn (e &Eval) is_disabled_fn_name_in_module(module_name string, fn_name string) bool {
    if fn_name in e.a.disabled_fns {
        return true
    }
    if !fn_name.contains('.') && module_name.len > 0 && module_name !in ['main', 'builtin'] {
        return '${module_name}.${fn_name}' in e.a.disabled_fns
    }
    return false
}

fn (e &Eval) call_result_value(result CallResult) Value {
    if result.values.len == 1 {
        return result.values[0]
    }
    return TupleValue{
        values: result.values
    }
}

fn (mut e Eval) write_back_mutated_args(node &flat.Node, result CallResult, mut_lvalues map[int]ResolvedLvalue) ! {
    e.write_back_mutated_arg_values(node, result.mutated_args, mut_lvalues)!
}

fn (mut e Eval) adapt_return_values(values []Value, return_type string) []Value {
    return_types := split_multi_return_types(return_type)
    if return_types.len > 0 {
        mut adapted := []Value{cap: values.len}
        for i, value in values {
            adapted << if i < return_types.len {
                e.adapt_value_to_type_name(value, return_types[i])
            } else {
                value
            }
        }
        return adapted
    }
    if values.len == 1 && return_type.len > 0 {
        return [e.adapt_value_to_type_name(values[0], return_type)]
    }
    return values.clone()
}

fn split_multi_return_types(return_type string) []string {
    if !return_type.starts_with('(') || !return_type.ends_with(')') {
        return []string{}
    }
    inner := return_type[1..return_type.len - 1]
    mut types := []string{}
    mut start := 0
    mut paren_depth := 0
    mut bracket_depth := 0
    for i := 0; i < inner.len; i++ {
        ch := inner[i]
        match ch {
            `(` {
                paren_depth++
            }
            `)` {
                if paren_depth > 0 {
                    paren_depth--
                }
            }
            `[` {
                bracket_depth++
            }
            `]` {
                if bracket_depth > 0 {
                    bracket_depth--
                }
            }
            `,` {
                if paren_depth == 0 && bracket_depth == 0 {
                    types << inner[start..i].trim_space()
                    start = i + 1
                }
            }
            else {}
        }
    }
    last := inner[start..].trim_space()
    if last.len > 0 {
        types << last
    }
    return if types.len > 1 { types } else { []string{} }
}

fn (e &Eval) minimum_arg_count(params []flat.NodeId) int {
    if params.len == 0 {
        return 0
    }
    last_param := e.node(params[params.len - 1])
    if last_param.typ.starts_with('...') {
        return params.len - 1
    }
    return params.len
}

fn (mut e Eval) bind_call_params(params []flat.NodeId, args []Value) ! {
    for i, param_id in params {
        param := e.node(param_id)
        if param.typ.starts_with('...') {
            elem_type := param.typ[3..]
            mut values := []Value{cap: if args.len > i { args.len - i } else { 0 }}
            for j := i; j < args.len; j++ {
                values << e.adapt_value_to_type_name(args[j], elem_type)
            }
            if param.value.len > 0 {
                e.declare_var_typed(param.value, ArrayValue{
                    elem_type_name: elem_type
                    values:         values
                }, '[]${elem_type}')
            }
            return
        }
        if i < args.len {
            e.declare_var_typed(param.value, e.adapt_value_to_type_name(args[i], param.typ),
                param.typ)
        }
    }
}

fn (mut e Eval) collect_mutated_param_args(params []flat.NodeId, args []Value) map[int]Value {
    mut mutated_args := map[int]Value{}
    for i, param_id in params {
        param := e.node(param_id)
        if param.value.len == 0 {
            continue
        }
        if param.typ.starts_with('...') {
            continue
        }
        found := e.lookup_var(param.value)
        if !found.found {
            continue
        }
        if param.typ.starts_with('&') {
            mutated_args[i] = found.value
            continue
        }
        if i < args.len && args[i] is FnValue && found.value is FnValue {
            fn_value := found.value as FnValue
            if fn_value.captures.len > 0 {
                mutated_args[i] = found.value
            }
        }
    }
    return mutated_args
}

fn (mut e Eval) write_back_fn_value(callee_id flat.NodeId, result CallResult) ! {
    if result.fn_value_changed && e.is_assignable_target(callee_id) {
        e.update_target(callee_id, Value(result.fn_value))!
    }
}

fn (mut e Eval) write_back_mutated_arg_values(node &flat.Node, mutated_args map[int]Value, mut_lvalues map[int]ResolvedLvalue) ! {
    for child_index := 1; child_index < node.children_count; child_index++ {
        arg_index := child_index - 1
        if arg_index !in mutated_args {
            continue
        }
        value := mutated_args[arg_index] or { continue }
        if resolved := mut_lvalues[arg_index] {
            signal := e.write_resolved_lvalue_flow(resolved, value)!
            if signal.kind != .normal {
                return error('v3.eval: unexpected `${signal.kind}` escaped mut argument writeback')
            }
            continue
        }
        arg_id := e.child(node, child_index)
        if e.is_assignable_target(arg_id) {
            e.update_target(arg_id, value)!
        }
    }
}

fn (e &Eval) is_assignable_target(id flat.NodeId) bool {
    if int(id) < 0 {
        return false
    }
    node := e.node(id)
    return node.kind in [.ident, .selector, .index]
}

fn (mut e Eval) call_fn_value(fv FnValue, args []Value) !CallResult {
    node := e.node(fv.node)
    mut params := []flat.NodeId{}
    mut body_start := 0
    children := e.children(node)
    for body_start < children.len {
        child := e.node(children[body_start])
        if child.kind != .ident {
            break
        }
        body_start++
    }
    for body_start < children.len {
        child_id := children[body_start]
        child := e.node(child_id)
        if child.kind == .param {
            params << child_id
            body_start++
            continue
        }
        break
    }
    e.open_scope()
    e.call_stack << CallFrame{
        module_name: fv.module_name
        file_name:   fv.file_name
        fn_name:     '<anonymous>'
        return_type: node.typ
        scope_idx:   e.scopes.len - 1
    }
    for name, value in fv.captures {
        e.declare_var_typed(name, value, fv.capture_types[name] or { '' })
    }
    e.bind_call_params(params, args)!
    signal := e.exec_stmts(children[body_start..])!
    e.run_deferred_stmts()!
    mutated_args := e.collect_mutated_param_args(params, args)
    mut updated_fn_value := fv
    if fv.captures.len > 0 {
        mut captures := fv.captures.clone()
        for name, _ in fv.captures {
            found := e.lookup_var(name)
            if found.found {
                captures[name] = found.value
            }
        }
        updated_fn_value = FnValue{
            node:          fv.node
            module_name:   fv.module_name
            file_name:     fv.file_name
            captures:      captures
            capture_types: fv.capture_types.clone()
        }
    }
    adapted_values := if signal.kind == .return_ {
        e.adapt_return_values(signal.values, node.typ)
    } else {
        []Value{}
    }
    e.close_scope()!
    e.call_stack.delete(e.call_stack.len - 1)
    if signal.kind == .return_ {
        return CallResult{
            values:           adapted_values
            mutated_args:     mutated_args
            fn_value_changed: fv.captures.len > 0
            fn_value:         updated_fn_value
        }
    }
    if signal.kind != .normal {
        return error('v3.eval: unexpected `${signal.kind}` escaped anonymous function')
    }
    return CallResult{
        values:           [void_value()]
        mutated_args:     mutated_args
        fn_value_changed: fv.captures.len > 0
        fn_value:         updated_fn_value
    }
}

fn (mut e Eval) eval_selector(node &flat.Node) !Value {
    left := e.eval_expr(e.child(node, 0))!
    return e.eval_selector_value(left, node.value)
}

fn (mut e Eval) eval_selector_value(left Value, field string) !Value {
    match left {
        ModuleValue {
            if value := e.lookup_const(left.name, field) {
                return value
            }
            return TypeValue{
                name: '${left.name}.${field}'
            }
        }
        TypeValue {
            if field == 'name' {
                return Value(left.name)
            }
            mod := e.type_value_module_name(left)
            enum_key := '${left.name.all_after_last('.')}.${field}'
            if value := e.lookup_const(mod, enum_key) {
                return e.enum_value(left.name, value)
            }
            if value := e.lookup_const(mod, field) {
                return e.enum_value(left.name, value)
            }
            return TypeValue{
                name: '${left.name}.${field}'
            }
        }
        ArrayValue {
            if field == 'len' {
                return Value(i64(left.values.len))
            }
            if field == 'cap' {
                return Value(i64(left.values.cap))
            }
        }
        MapValue {
            if field == 'len' {
                return Value(i64(left.entries.len))
            }
        }
        string {
            if field == 'len' {
                return Value(i64(left.len))
            }
        }
        StructValue {
            if field in left.fields {
                return left.fields[field] or { void_value() }
            }
        }
        SumValue {
            return e.eval_sum_selector(left, field)
        }
        else {}
    }

    return error('v3.eval: unsupported selector `${field}` on `${e.runtime_type_name(left)}`')
}

fn (e &Eval) eval_sum_selector(value SumValue, field string) !Value {
    if field == '_typ' {
        return Value(i64(e.sum_variant_index(value.type_name, value.variant_name)))
    }
    if value.payload is StructValue {
        payload := value.payload as StructValue
        if field in payload.fields {
            return payload.fields[field] or { void_value() }
        }
    }
    return error('v3.eval: unknown sum type field `${field}` on `${value.type_name}`')
}

fn (e &Eval) sum_variant_index(type_name string, variant_name string) int {
    if type_name in e.sum_types {
        variants := e.sum_types[type_name]
        sum_module := if type_name.contains('.') {
            type_name.all_before_last('.')
        } else {
            e.current_module_name()
        }
        expected_name := e.qualify_type_name(sum_module, variant_name)
        for i, variant in variants {
            if variant == expected_name || variant == variant_name {
                return i
            }
        }
        mut short_match_index := -1
        for i, variant in variants {
            if variant.all_after_last('.') == variant_name.all_after_last('.') {
                if short_match_index >= 0 {
                    return 0
                }
                short_match_index = i
            }
        }
        if short_match_index >= 0 {
            return short_match_index
        }
    }
    return 0
}

fn (mut e Eval) eval_index(node &flat.Node) !Value {
    container := e.eval_expr(e.child(node, 0))!
    if node.value == 'range' {
        start := if node.children_count > 1 && e.node(e.child(node, 1)).kind != .empty {
            int(e.value_as_int(e.eval_expr(e.child(node, 1))!)!)
        } else {
            0
        }
        mut end := 0
        match container {
            ArrayValue { end = container.values.len }
            string { end = container.len }
            else {}
        }

        if node.children_count > 2 {
            end = int(e.value_as_int(e.eval_expr(e.child(node, 2))!)!)
        }
        return e.slice_value(container, start, end)!
    }
    index := if container is MapValue {
        e.eval_expr_expected(e.child(node, 1), container.key_type_name)!
    } else {
        e.eval_expr(e.child(node, 1))!
    }
    return e.index_value(container, index)
}

fn (mut e Eval) eval_index_flow(node &flat.Node) !FlowSignal {
    container_signal := e.eval_expr_flow(e.child(node, 0))!
    if container_signal.kind != .normal {
        return container_signal
    }
    container := flow_value(container_signal)
    if node.value == 'range' {
        mut start := 0
        if node.children_count > 1 && e.node(e.child(node, 1)).kind != .empty {
            start_signal := e.eval_expr_flow(e.child(node, 1))!
            if start_signal.kind != .normal {
                return start_signal
            }
            start = int(e.value_as_int(flow_value(start_signal))!)
        }
        mut end := 0
        match container {
            ArrayValue { end = container.values.len }
            string { end = container.len }
            else {}
        }

        if node.children_count > 2 {
            end_signal := e.eval_expr_flow(e.child(node, 2))!
            if end_signal.kind != .normal {
                return end_signal
            }
            end = int(e.value_as_int(flow_value(end_signal))!)
        }
        return value_flow(e.slice_value(container, start, end)!)
    }
    index_signal := if container is MapValue {
        e.eval_expr_flow_expected(e.child(node, 1), container.key_type_name)!
    } else {
        e.eval_expr_flow(e.child(node, 1))!
    }
    if index_signal.kind != .normal {
        return index_signal
    }
    return value_flow(e.index_value(container, flow_value(index_signal))!)
}

fn (mut e Eval) index_value(container Value, index Value) !Value {
    match container {
        ArrayValue {
            idx := int(e.value_as_int(index)!)
            if idx < 0 || idx >= container.values.len {
                return error('v3.eval: array index out of bounds')
            }
            return container.values[idx]
        }
        MapValue {
            value, ok := e.map_lookup(container, e.adapt_value_to_type_name(index,
                container.key_type_name))
            if ok {
                return value
            }
            return container.default_value
        }
        string {
            idx := int(e.value_as_int(index)!)
            if idx < 0 || idx >= container.len {
                return error('v3.eval: string index out of bounds')
            }
            return Value(i64(container[idx]))
        }
        else {
            return error('v3.eval: unsupported index target `${e.runtime_type_name(container)}`')
        }
    }
}

fn (e &Eval) slice_value(container Value, start int, end int) !Value {
    match container {
        ArrayValue {
            mut arr := container
            arr.values = arr.values[start..end].clone()
            return arr
        }
        string {
            sliced := container[start..end]
            return Value(sliced)
        }
        else {
            return error('v3.eval: slicing is only supported for arrays and strings')
        }
    }
}

fn (mut e Eval) eval_if_value(node &flat.Node) !Value {
    signal := e.eval_if_value_flow(node)!
    return flow_values_value(signal.values)
}

fn (mut e Eval) eval_if_value_flow(node &flat.Node) !FlowSignal {
    return e.eval_if_value_flow_expected(node, '')
}

fn (mut e Eval) eval_if_value_flow_expected(node &flat.Node, expected_type string) !FlowSignal {
    if node.children_count < 2 {
        return value_flow(void_value())
    }
    cond_id := e.child(node, 0)
    cond_is_guard := e.node(cond_id).kind == .decl_assign
    if cond_is_guard {
        e.open_scope()
    }
    cond_signal := e.eval_condition_flow(cond_id)!
    if cond_signal.kind != .normal {
        if cond_is_guard {
            e.close_scope()!
        }
        return cond_signal
    }
    if e.value_as_bool(flow_value(cond_signal))! {
        mut smartcast_scope := false
        if !cond_is_guard {
            if binding := e.smartcast_binding_from_condition(cond_id) {
                e.open_scope()
                e.declare_var_typed(binding.name, binding.value, binding.type_name)
                smartcast_scope = true
            }
        }
        signal := e.eval_value_expr_flow_expected(e.child(node, 1), expected_type)!
        if smartcast_scope {
            e.close_scope()!
        }
        if cond_is_guard {
            e.close_scope()!
        }
        return signal
    }
    if cond_is_guard {
        e.close_scope()!
    }
    if node.children_count > 2 {
        return e.eval_value_expr_flow_expected(e.child(node, 2), expected_type)
    }
    return value_flow(void_value())
}

fn (mut e Eval) eval_value_expr_flow(id flat.NodeId) !FlowSignal {
    return e.eval_value_expr_flow_expected(id, '')
}

fn (mut e Eval) eval_value_expr_flow_expected(id flat.NodeId, expected_type string) !FlowSignal {
    if int(id) >= 0 {
        node := e.node(id)
        if node.kind == .block {
            return e.eval_block_value_flow_expected(node, expected_type)
        }
    }
    return e.eval_expr_flow_expected(id, expected_type)
}

fn (mut e Eval) eval_block_value(node &flat.Node) !Value {
    signal := e.eval_block_value_flow(node)!
    if signal.kind == .return_ && signal.values.len > 0 {
        return flow_values_value(signal.values)
    }
    return flow_values_value(signal.values)
}

fn (mut e Eval) eval_block_value_flow(node &flat.Node) !FlowSignal {
    return e.eval_block_value_flow_expected(node, '')
}

fn (mut e Eval) eval_block_value_flow_expected(node &flat.Node, expected_type string) !FlowSignal {
    return e.eval_block_value_flow_collect(node, false, expected_type)
}

fn (mut e Eval) eval_block_value_flow_collect(node &flat.Node, collect_expr_values bool, expected_type string) !FlowSignal {
    e.open_scope()
    mut values := []Value{}
    for child_id in e.children(node) {
        child := e.node(child_id)
        if child.kind == .expr_stmt && child.children_count > 0 {
            expr_id := e.child(child, 0)
            expr := e.node(expr_id)
            if expr.kind == .infix && expr.op == .left_shift {
                signal := e.exec_stmt(child_id)!
                if signal.kind != .normal {
                    e.close_scope()!
                    return signal
                }
                continue
            }
            signal := e.eval_expr_flow_expected(expr_id, expected_type)!
            if signal.kind != .normal {
                e.close_scope()!
                return signal
            }
            expr_values := flow_values_or_void(signal.values)
            if collect_expr_values {
                for expr_value in expr_values {
                    if expr_value !is VoidValue {
                        values << expr_value
                    }
                }
            } else {
                values = expr_values.clone()
            }
            continue
        }
        if child.kind == .block {
            collect_child_expr_values := node.children_count == 1
                && e.block_has_only_expr_stmts(child) && child.children_count > 1
            signal := e.eval_block_value_flow_collect(child, collect_child_expr_values,
                expected_type)!
            if signal.kind != .normal {
                e.close_scope()!
                return signal
            }
            values = flow_values_or_void(signal.values)
            continue
        }
        signal := e.exec_stmt(child_id)!
        if signal.kind != .normal {
            e.close_scope()!
            return signal
        }
    }
    e.close_scope()!
    return FlowSignal{
        values: flow_values_or_void(values)
    }
}

fn (e &Eval) block_has_only_expr_stmts(node &flat.Node) bool {
    if node.children_count == 0 {
        return false
    }
    for child_id in e.children(node) {
        if e.node(child_id).kind != .expr_stmt {
            return false
        }
    }
    return true
}

fn (mut e Eval) eval_array_init(node &flat.Node) !Value {
    return flow_value(e.eval_array_init_flow(node)!)
}

fn (mut e Eval) eval_array_init_flow(node &flat.Node) !FlowSignal {
    array_type_name := if node.typ.len > 0 { node.typ } else { node.value }
    is_fixed_array := is_fixed_array_type_name(array_type_name)
    elem_type_name := if is_fixed_array {
        fixed_array_elem_type_name(array_type_name)
    } else {
        node.value
    }
    mut len := 0
    mut cap := 0
    mut has_cap := false
    mut init_id := flat.empty_node
    mut has_init := false
    mut values := []Value{}
    for child_id in e.children(node) {
        child := e.node(child_id)
        if child.kind == .field_init {
            if child.value == 'len' {
                signal := e.eval_expr_flow(e.child(child, 0))!
                if signal.kind != .normal {
                    return signal
                }
                len = int(e.value_as_int(flow_value(signal))!)
            } else if child.value == 'cap' {
                signal := e.eval_expr_flow(e.child(child, 0))!
                if signal.kind != .normal {
                    return signal
                }
                cap = int(e.value_as_int(flow_value(signal))!)
                has_cap = true
            } else if child.value == 'init' {
                init_id = e.child(child, 0)
                has_init = true
            }
        } else {
            signal := e.eval_expr_flow_expected(child_id, elem_type_name)!
            if signal.kind != .normal {
                return signal
            }
            values << e.adapt_value_to_type_name(flow_value(signal), elem_type_name)
        }
    }
    if len > 0 || has_cap {
        array_cap := if has_cap { cap } else { len }
        return e.eval_array_init_values(len, array_cap, has_init, init_id, elem_type_name)
    }
    if is_fixed_array && values.len == 0 {
        fixed_len := e.fixed_array_len(array_type_name)!
        return e.eval_array_init_values(fixed_len, fixed_len, has_init, init_id, elem_type_name)
    }
    return value_flow(ArrayValue{
        elem_type_name: elem_type_name
        values:         values
    })
}

fn (mut e Eval) eval_array_init_values(len int, cap int, has_init bool, init_id flat.NodeId, elem_type_name string) !FlowSignal {
    mut values := []Value{cap: cap}
    for i in 0 .. len {
        if has_init {
            e.open_scope()
            e.declare_var_typed('index', Value(i64(i)), 'int')
            signal := e.eval_expr_flow_expected(init_id, elem_type_name) or {
                e.close_scope()!
                return err
            }
            e.close_scope()!
            if signal.kind != .normal {
                return signal
            }
            values << e.adapt_value_to_type_name(flow_value(signal), elem_type_name)
        } else {
            values << e.zero_value_for_type_name(elem_type_name)
        }
    }
    return value_flow(ArrayValue{
        elem_type_name: elem_type_name
        values:         values
    })
}

fn is_fixed_array_type_name(type_name string) bool {
    if type_name.starts_with('[]') || type_name.starts_with('map[') {
        return false
    }
    return type_name.contains('[') && (type_name.ends_with(']') || type_name.starts_with('['))
}

fn (mut e Eval) fixed_array_len(type_name string) !int {
    return e.fixed_array_len_in_module(type_name, e.current_module_name())
}

fn (mut e Eval) fixed_array_len_in_module(type_name string, module_name string) !int {
    text := fixed_array_len_text(type_name)
    if len := fixed_array_len_literal(text) {
        return len
    }
    if value := e.lookup_const(module_name, text) {
        return int(e.value_as_int(value)!)
    }
    if text.contains('.') {
        mod_name := text.all_before_last('.')
        const_name := text.all_after_last('.')
        if value := e.lookup_const(mod_name, const_name) {
            return int(e.value_as_int(value)!)
        }
    }
    return 0
}

fn fixed_array_len_literal(text string) ?int {
    normalized := text.replace('_', '')
    if normalized.len == 0 {
        return none
    }
    mut len := 0
    for ch in normalized {
        if ch < `0` || ch > `9` {
            return none
        }
        len = len * 10 + int(ch - `0`)
    }
    return len
}

fn fixed_array_len_text(type_name string) string {
    return type_name.all_after('[').all_before(']').trim_space()
}

fn fixed_array_elem_type_name(type_name string) string {
    if type_name.starts_with('[') {
        return type_name.all_after(']')
    }
    return type_name.all_before('[')
}

fn (mut e Eval) eval_map_init(node &flat.Node) !Value {
    return flow_value(e.eval_map_init_flow(node)!)
}

fn (mut e Eval) eval_map_init_flow(node &flat.Node) !FlowSignal {
    mut key_type, mut value_type := split_map_type(node.value)
    children := e.children(node)
    mut keys := []Value{}
    mut values := []Value{}
    mut i := 0
    for i + 1 < children.len {
        key_signal := e.eval_expr_flow_expected(children[i], key_type)!
        if key_signal.kind != .normal {
            return key_signal
        }
        key := flow_value(key_signal)
        if key_type.len == 0 {
            key_type = e.infer_expr_type_name(children[i])
            if key_type.len == 0 {
                key_type = e.runtime_type_name(key)
            }
        }
        typed_key := e.adapt_value_to_type_name(key, key_type)
        value_signal := e.eval_expr_flow_expected(children[i + 1], value_type)!
        if value_signal.kind != .normal {
            return value_signal
        }
        value := flow_value(value_signal)
        if value_type.len == 0 {
            value_type = e.infer_expr_type_name(children[i + 1])
            if value_type.len == 0 {
                value_type = e.runtime_type_name(value)
            }
        }
        keys << typed_key
        values << value
        i += 2
    }
    mut m := MapValue{
        key_type_name:   key_type
        value_type_name: value_type
        default_value:   e.zero_value_for_type_name(value_type)
    }
    for j, key in keys {
        m = e.map_set_value(m, key, values[j])
    }
    return value_flow(m)
}

fn (mut e Eval) eval_string_interp_flow(node &flat.Node) !FlowSignal {
    mut out := ''
    for child_id in e.children(node) {
        child := e.node(child_id)
        if child.kind == .string_literal {
            out += child.value
            continue
        }
        signal := e.eval_expr_flow(child_id)!
        if signal.kind != .normal {
            return signal
        }
        out += e.display_string(flow_value(signal))!
    }
    return value_flow(Value(out))
}

fn split_map_type(type_name string) (string, string) {
    if !type_name.starts_with('map[') {
        return '', ''
    }
    inner := type_name[4..]
    if idx := inner.index(']') {
        return inner[..idx], inner[idx + 1..]
    }
    return '', ''
}

fn (mut e Eval) eval_struct_init(node &flat.Node) !Value {
    return flow_value(e.eval_struct_init_flow(node)!)
}

fn (mut e Eval) eval_struct_init_flow(node &flat.Node) !FlowSignal {
    type_name := e.normalize_type_name(node.value)
    mut st := e.zero_struct_value(type_name)
    mut positional := 0
    for child_id in e.children(node) {
        child := e.node(child_id)
        if child.kind != .field_init {
            continue
        }
        if child.value.len > 0 {
            field_type := e.struct_field_type_name(st, child.value)
            value_signal := e.eval_expr_flow_expected(e.child(child, 0), field_type)!
            if value_signal.kind != .normal {
                return value_signal
            }
            value := flow_value(value_signal)
            st.fields[child.value] = e.adapt_value_to_type_name(value, e.struct_field_type_name(st,
                child.value))
        } else {
            fields := e.struct_fields(type_name)
            if positional < fields.len {
                field := fields[positional]
                field_type := e.qualify_nested_type_name(field.module_name, field.typ)
                value_signal := e.eval_expr_flow_expected(e.child(child, 0), field_type)!
                if value_signal.kind != .normal {
                    return value_signal
                }
                value := flow_value(value_signal)
                st.fields[field.name] = e.adapt_value_to_type_name(value, field_type)
            }
            positional++
        }
    }
    return value_flow(st)
}

fn (mut e Eval) eval_assoc(node &flat.Node) !Value {
    return flow_value(e.eval_assoc_flow(node)!)
}

fn (mut e Eval) eval_assoc_flow(node &flat.Node) !FlowSignal {
    if node.children_count == 0 {
        return value_flow(e.zero_struct_value(node.value))
    }
    base_signal := e.eval_expr_flow(e.child(node, 0))!
    if base_signal.kind != .normal {
        return base_signal
    }
    base := flow_value(base_signal)
    if base !is StructValue {
        return error('v3.eval: assoc base must be struct')
    }
    mut st := base as StructValue
    for i in 1 .. node.children_count {
        field := e.child_node(node, i)
        if field.kind == .field_init {
            field_type := e.struct_field_type_name(st, field.value)
            value_signal := e.eval_expr_flow_expected(e.child(field, 0), field_type)!
            if value_signal.kind != .normal {
                return value_signal
            }
            st.fields[field.value] = e.adapt_value_to_type_name(flow_value(value_signal),
                field_type)
        }
    }
    return value_flow(st)
}