module eval

import os
import os.cmdline as host_cmdline
import strconv
import time
import v2.ast
import v2.parser
import v2.pref
import v2.token

type Value = ArrayValue
    | FlagsValue
    | MapValue
    | ModuleValue
    | RangeValue
    | StructValue
    | TupleValue
    | TypeValue
    | VoidValue
    | bool
    | f64
    | i64
    | string

fn value_f64_payload(value Value) f64 {
    data := unsafe { (&u64(&value))[1] }
    if data == 0 {
        return 0.0
    }
    return unsafe { *(&f64(voidptr(data))) }
}

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

struct FlagsValue {}

struct MapEntry {
    key   Value
    value Value
}

struct MapValue {
    default_value Value
mut:
    entries []MapEntry
}

struct ModuleValue {
    name string
}

struct RangeValue {
    start     i64
    end       i64
    inclusive bool
}

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

struct TupleValue {
    values []Value
}

struct TypeValue {
    name string
}

struct VoidValue {}

struct FunctionDef {
    decl      ast.FnDecl
    file_name string
}

struct ConstEntry {
    expr      ast.Expr
    file_name string
mut:
    cached     bool
    evaluating bool
    value      Value
}

struct SumTypeInfo {
    module_name string
    name        string
mut:
    variant_tags      map[string]int
    tag_field_aliases map[int][]string
}

struct InferredSumTypeVariant {
    tag          int
    variant_name string
}

struct WrappedSumTypeVariant {
    tag     int
    payload Value
}

struct ScopeFrame {
mut:
    vars   map[string]Value
    defers [][]ast.Stmt
}

struct CallFrame {
    module_name string
    file_name   string
    fn_name     string
}

struct MaybeValue {
    found bool
    value Value
}

struct MaybeCallResult {
    found  bool
    result CallResult
}

struct MaybeFunctionTarget {
    found       bool
    module_name string
    fn_name     string
}

struct CallResult {
    values []Value
mut:
    mut_args map[int]Value
}

enum FlowKind {
    normal
    break_
    continue_
    goto_
    return_
}

struct FlowSignal {
    kind   FlowKind
    label  string
    values []Value
}

fn void_value() Value {
    return VoidValue{}
}

fn wrap_result_ok(value Value) Value {
    return StructValue{
        type_name: 'Result'
        fields:    {
            'is_error': Value(false)
            'err':      Value('')
            'data':     value
        }
    }
}

fn wrap_result_err(message string) Value {
    return StructValue{
        type_name: 'Result'
        fields:    {
            'is_error': Value(true)
            'err':      Value(message)
            'data':     void_value()
        }
    }
}

fn wrap_option_ok(value Value) Value {
    return StructValue{
        type_name: 'Option'
        fields:    {
            'state': Value(i64(0))
            'err':   Value('')
            'data':  value
        }
    }
}

fn wrap_option_none() Value {
    return StructValue{
        type_name: 'Option'
        fields:    {
            'state': Value(i64(1))
            'err':   Value('')
            'data':  void_value()
        }
    }
}

fn os_result_value(result os.Result) Value {
    return StructValue{
        type_name: 'os.Result'
        fields:    {
            'exit_code': Value(i64(result.exit_code))
            'output':    Value(result.output)
        }
    }
}

fn is_option_value(value Value) bool {
    return value is StructValue && 'state' in value.fields && 'err' in value.fields
        && 'data' in value.fields
}

fn is_result_value(value Value) bool {
    return value is StructValue && 'is_error' in value.fields && 'err' in value.fields
        && 'data' in value.fields
}

// Eval interprets the v2 AST directly for a limited subset of V.
pub struct Eval {
pub mut:
    capture_output bool
    prefs          pref.Preferences
mut:
    stdout_data        string
    stderr_data        string
    functions          map[string]map[string]FunctionDef
    consts             map[string]map[string]ConstEntry
    sum_types          map[string]SumTypeInfo
    struct_field_types map[string]map[string]map[string]ast.Expr
    struct_embeds      map[string]map[string][]string
    type_kinds         map[string]map[string]string
    type_names         map[string]map[string]bool
    file_import_alias  map[string]map[string]string
    modules            map[string]bool
    scopes             []ScopeFrame
    call_stack         []CallFrame
    next_token_pos_id  i64
}

// new returns a new evaluator configured for direct execution.
pub fn new(prefs_ &pref.Preferences) Eval {
    return Eval{
        capture_output: false
        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(), 'v2_eval_${os.getpid()}_${time.now().unix_micro()}.v')
    os.write_file(tmp_file, code)!
    defer {
        os.rm(tmp_file) or {}
    }
    mut file_set := token.FileSet.new()
    mut par := parser.Parser.new(&e.prefs)
    files := par.parse_files([tmp_file], mut file_set)
    return e.run_files(files)
}

// run_files executes parsed AST files and invokes `main.main`.
pub fn (mut e Eval) run_files(files []ast.File) ![]Value {
    e.reset()
    e.register_files(files)!
    return e.call_function('main', 'main', []Value{})!.values
}

fn (mut e Eval) reset() {
    e.stdout_data = ''
    e.stderr_data = ''
    e.functions = map[string]map[string]FunctionDef{}
    e.consts = map[string]map[string]ConstEntry{}
    e.sum_types = map[string]SumTypeInfo{}
    e.struct_field_types = map[string]map[string]map[string]ast.Expr{}
    e.struct_embeds = map[string]map[string][]string{}
    e.type_kinds = map[string]map[string]string{}
    e.type_names = map[string]map[string]bool{}
    e.file_import_alias = map[string]map[string]string{}
    e.modules = map[string]bool{}
    e.scopes = []ScopeFrame{}
    e.call_stack = []CallFrame{}
    e.next_token_pos_id = 0
}

fn (mut e Eval) register_files(files []ast.File) ! {
    for file in files {
        e.modules[file.mod] = true
        mut import_aliases := map[string]string{}
        for imp in file.imports {
            import_aliases[imp.alias] = imp.name.all_after_last('.')
        }
        e.file_import_alias[file.name] = import_aliases.clone()
        if file.mod !in e.functions {
            e.functions[file.mod] = map[string]FunctionDef{}
        }
        if file.mod !in e.consts {
            e.consts[file.mod] = map[string]ConstEntry{}
        }
        if file.mod !in e.type_names {
            e.type_names[file.mod] = map[string]bool{}
        }
        if file.mod !in e.struct_field_types {
            e.struct_field_types[file.mod] = map[string]map[string]ast.Expr{}
        }
        if file.mod !in e.struct_embeds {
            e.struct_embeds[file.mod] = map[string][]string{}
        }
        if file.mod !in e.type_kinds {
            e.type_kinds[file.mod] = map[string]string{}
        }
        for stmt in file.stmts {
            match stmt {
                ast.ConstDecl {
                    for field in stmt.fields {
                        key := if field.name.contains('.') {
                            field.name.all_after_last('.')
                        } else {
                            field.name
                        }
                        e.consts[file.mod][key] = ConstEntry{
                            expr:      field.value
                            file_name: file.name
                            value:     void_value()
                        }
                    }
                }
                ast.EnumDecl {
                    e.type_names[file.mod][stmt.name] = true
                    e.type_kinds[file.mod][stmt.name] = 'Enum'
                    is_flag := stmt.attributes.has('flag')
                    mut next_value := if is_flag { i64(1) } else { i64(0) }
                    for field in stmt.fields {
                        key := field.name
                        value := if field.value is ast.EmptyExpr {
                            Value(next_value)
                        } else if field.value is ast.BasicLiteral && field.value.kind == .number {
                            Value(strconv.parse_int(field.value.value, 0, 64)!)
                        } else {
                            Value(next_value)
                        }
                        int_value := e.value_as_int(value)!
                        e.consts[file.mod][key] = ConstEntry{
                            expr:      ast.empty_expr
                            file_name: file.name
                            cached:    true
                            value:     int_value
                        }
                        next_value = if is_flag {
                            if int_value <= 0 { i64(1) } else { int_value * 2 }
                        } else {
                            int_value + 1
                        }
                    }
                }
                ast.InterfaceDecl {
                    e.type_names[file.mod][stmt.name] = true
                    e.type_kinds[file.mod][stmt.name] = 'Interface'
                }
                ast.FnDecl {
                    e.functions[file.mod][stmt.name] = FunctionDef{
                        decl:      stmt
                        file_name: file.name
                    }
                    if stmt.is_method {
                        receiver_type_name := stmt.receiver.typ.name()
                        if receiver_type_name != '' && receiver_type_name != 'EmptyExpr' {
                            e.functions[file.mod]['${receiver_type_name}__${stmt.name}'] = FunctionDef{
                                decl:      stmt
                                file_name: file.name
                            }
                            short_receiver_name := receiver_type_name.all_after_last('.')
                            if short_receiver_name != receiver_type_name {
                                e.functions[file.mod]['${short_receiver_name}__${stmt.name}'] = FunctionDef{
                                    decl:      stmt
                                    file_name: file.name
                                }
                            }
                            normalized_receiver_name :=
                                receiver_type_name.trim_left('&').trim_right('*')
                            if normalized_receiver_name != ''
                                && normalized_receiver_name != receiver_type_name {
                                e.functions[file.mod]['${normalized_receiver_name}__${stmt.name}'] = FunctionDef{
                                    decl:      stmt
                                    file_name: file.name
                                }
                                short_normalized_name :=
                                    normalized_receiver_name.all_after_last('.')
                                if short_normalized_name != normalized_receiver_name {
                                    e.functions[file.mod]['${short_normalized_name}__${stmt.name}'] = FunctionDef{
                                        decl:      stmt
                                        file_name: file.name
                                    }
                                }
                            }
                        }
                    }
                }
                ast.StructDecl {
                    e.type_names[file.mod][stmt.name] = true
                    e.type_kinds[file.mod][stmt.name] = 'Struct'
                    mut field_types := map[string]ast.Expr{}
                    for field in stmt.fields {
                        field_types[field.name] = field.typ
                    }
                    e.struct_field_types[file.mod][stmt.name] = field_types.clone()
                    e.struct_embeds[file.mod][stmt.name] = stmt.embedded.map(e.type_expr_name(it))
                }
                ast.TypeDecl {
                    e.type_names[file.mod][stmt.name] = true
                    if stmt.variants.len > 0 {
                        e.type_kinds[file.mod][stmt.name] = 'SumType'
                        e.register_sum_type(file.mod, stmt)
                    } else {
                        e.type_kinds[file.mod][stmt.name] = 'Alias'
                    }
                }
                else {}
            }
        }
    }
    if 'main' !in e.functions || 'main' !in e.functions['main'] {
        return error('v2.eval: missing main.main entry point')
    }
}

fn add_type_name_alias(mut aliases []string, alias string) {
    if alias != '' && alias !in aliases {
        aliases << alias
    }
}

fn (e &Eval) type_name_aliases(module_name string, type_name string) []string {
    mut aliases := []string{}
    if type_name == '' {
        return aliases
    }
    add_type_name_alias(mut aliases, type_name)
    if type_name.starts_with('[]') {
        for inner_alias in e.type_name_aliases(module_name, type_name[2..]) {
            add_type_name_alias(mut aliases, '[]${inner_alias}')
        }
        return aliases
    }
    if type_name.starts_with('map[') {
        inner := type_name[4..]
        if bracket_idx := inner.index(']') {
            key_name := inner[..bracket_idx]
            value_name := inner[bracket_idx + 1..]
            key_aliases := e.type_name_aliases(module_name, key_name)
            value_aliases := e.type_name_aliases(module_name, value_name)
            for key_alias in key_aliases {
                for value_alias in value_aliases {
                    add_type_name_alias(mut aliases, 'map[${key_alias}]${value_alias}')
                }
            }
        }
        return aliases
    }
    if type_name.contains('__') {
        add_type_name_alias(mut aliases, type_name.replace('__', '.'))
        add_type_name_alias(mut aliases, type_name.all_after_last('__'))
        return aliases
    }
    if type_name.contains('.') {
        add_type_name_alias(mut aliases, type_name.replace('.', '__'))
        add_type_name_alias(mut aliases, type_name.all_after_last('.'))
        return aliases
    }
    if module_name != '' {
        add_type_name_alias(mut aliases, '${module_name}.${type_name}')
        add_type_name_alias(mut aliases, '${e.mangled_module_name(module_name)}__${type_name}')
    }
    return aliases
}

fn (e &Eval) sumtype_variant_field_name(variant_name string) string {
    if variant_name.starts_with('[]') {
        return 'Array_${variant_name[2..].replace('.', '__')}'
    }
    if variant_name.starts_with('map[') {
        inner := variant_name[4..]
        if bracket_idx := inner.index(']') {
            key := inner[..bracket_idx].replace('.', '__')
            val := inner[bracket_idx + 1..].replace('.', '__')
            return 'Map_${key}_${val}'
        }
    }
    if variant_name.contains('__') {
        return variant_name.all_after_last('__')
    }
    if variant_name.contains('.') {
        return variant_name.all_after_last('.')
    }
    return variant_name
}

fn (mut e Eval) register_sum_type(module_name string, decl ast.TypeDecl) {
    mut info := SumTypeInfo{
        module_name:       module_name
        name:              decl.name
        variant_tags:      map[string]int{}
        tag_field_aliases: map[int][]string{}
    }
    for tag, variant in decl.variants {
        variant_name := e.type_expr_name(variant)
        for alias in e.type_name_aliases(module_name, variant_name) {
            info.variant_tags[alias] = tag
            field_alias := '_' + e.sumtype_variant_field_name(alias)
            mut field_aliases := []string{}
            if tag in info.tag_field_aliases {
                field_aliases = info.tag_field_aliases[tag]
            }
            if field_alias !in field_aliases {
                field_aliases << field_alias
            }
            info.tag_field_aliases[tag] = field_aliases
        }
    }
    for alias in e.type_name_aliases(module_name, decl.name) {
        e.sum_types[alias] = info
    }
}

fn is_composite_sumtype_lookup_name(name string) bool {
    return name.starts_with('[]') || name.starts_with('map[')
        || (name.starts_with('[') && name.contains(']')) || name.starts_with('?')
        || name.starts_with('!') || name.starts_with('chan ')
        || name.starts_with('thread ')
}

fn (e &Eval) sum_type_info(type_name string) ?SumTypeInfo {
    trimmed := type_name.trim_left('&').trim_right('*')
    if trimmed in e.sum_types {
        return e.sum_types[trimmed]
    }
    if is_composite_sumtype_lookup_name(trimmed) {
        return none
    }
    if trimmed.contains('.') {
        short_name := trimmed.all_after_last('.')
        if short_name in e.sum_types {
            return e.sum_types[short_name]
        }
    }
    if trimmed.contains('__') {
        short_name := trimmed.all_after_last('__')
        if short_name in e.sum_types {
            return e.sum_types[short_name]
        }
        dotted := trimmed.replace('__', '.')
        if dotted in e.sum_types {
            return e.sum_types[dotted]
        }
    }
    return none
}

fn (e &Eval) is_sum_type_name(type_name string) bool {
    _ = e.sum_type_info(type_name) or { return false }
    return true
}

fn (e &Eval) lookup_sumtype_variant_tag(info SumTypeInfo, variant_name string) ?int {
    for alias in e.type_name_aliases(info.module_name, variant_name) {
        if alias in info.variant_tags {
            return info.variant_tags[alias]
        }
    }
    return none
}

fn builtin_type_kind_alias(name string) ?string {
    trimmed := name.all_after_last('.')
    return match trimmed {
        'bool', 'f32', 'f64', 'float_literal', 'i8', 'i16', 'i32', 'int', 'i64', 'int_literal',
        'u8', 'byte', 'u16', 'u32', 'u64' {
            'Primitive'
        }
        'byteptr', 'charptr', 'voidptr' {
            'Alias'
        }
        'char' {
            'Char'
        }
        'isize' {
            'ISize'
        }
        'nil' {
            'Nil'
        }
        'none' {
            'None'
        }
        'rune' {
            'Rune'
        }
        'string' {
            'String'
        }
        'usize' {
            'USize'
        }
        'void' {
            'Void'
        }
        else {
            none
        }
    }
}

fn (e &Eval) registered_type_kind(type_name string) ?string {
    for alias in struct_field_lookup_candidates(type_name) {
        mut module_name := ''
        mut short_type_name := alias
        if alias.contains('.') {
            module_name = alias.all_before_last('.')
            short_type_name = alias.all_after_last('.')
        }
        if module_name != '' {
            if module_kinds := e.type_kinds[module_name] {
                if short_type_name in module_kinds {
                    return module_kinds[short_type_name] or { return none }
                }
            }
            continue
        }
        current_module := e.current_module_name()
        if module_kinds := e.type_kinds[current_module] {
            if short_type_name in module_kinds {
                return module_kinds[short_type_name] or { return none }
            }
        }
        for module_kinds in e.type_kinds.values() {
            if short_type_name in module_kinds {
                return module_kinds[short_type_name] or { return none }
            }
        }
    }
    return none
}

fn (e &Eval) type_value_variant_aliases(info SumTypeInfo, value TypeValue) []string {
    mut aliases := e.type_name_aliases(info.module_name, value.name)
    if type_kind := e.registered_type_kind(value.name) {
        add_type_name_alias(mut aliases, type_kind)
    }
    if builtin_kind := builtin_type_kind_alias(value.name) {
        add_type_name_alias(mut aliases, builtin_kind)
    }
    add_type_name_alias(mut aliases, 'Type')
    return aliases
}

fn (e &Eval) canonical_sumtype_variant_name(info SumTypeInfo, alias string) string {
    if alias.contains('.') {
        return alias
    }
    if alias.contains('__') {
        dotted := alias.replace('__', '.')
        if dotted.contains('.') {
            return dotted
        }
    }
    short_name := alias.all_after_last('__')
    if info.module_name != '' && short_name != '' {
        return '${info.module_name}.${short_name}'
    }
    if short_name != '' {
        return short_name
    }
    return alias
}

fn (e &Eval) lookup_struct_field_names(type_name string) ?[]string {
    for candidate in struct_field_lookup_candidates(type_name) {
        mut module_name := ''
        mut short_type_name := candidate
        if candidate.contains('.') {
            module_name = candidate.all_before_last('.')
            short_type_name = candidate.all_after_last('.')
        }
        if module_name != '' {
            if module_fields := e.struct_field_types[module_name] {
                if type_fields := module_fields[short_type_name] {
                    return type_fields.keys()
                }
            }
            continue
        }
        current_module := e.current_module_name()
        if module_fields := e.struct_field_types[current_module] {
            if type_fields := module_fields[short_type_name] {
                return type_fields.keys()
            }
        }
        for _, module_fields in e.struct_field_types {
            if type_fields := module_fields[short_type_name] {
                return type_fields.keys()
            }
        }
    }
    return none
}

fn (e &Eval) zero_value_for_type_name(type_name string) Value {
    if type_name == '' {
        return void_value()
    }
    if type_name.starts_with('[]') {
        return ArrayValue{}
    }
    if type_name.starts_with('map[') {
        inner := type_name[4..]
        if bracket_idx := inner.index(']') {
            return MapValue{
                default_value: e.zero_value_for_type_name(inner[bracket_idx + 1..])
            }
        }
        return MapValue{}
    }
    if type_name.starts_with('?') || type_name.starts_with('!') {
        return void_value()
    }
    match type_name {
        'bool' {
            return false
        }
        'byte', 'char', 'i8', 'i16', 'i32', 'int', 'i64', 'isize', 'rune', 'u8', 'u16', 'u32',
        'u64', 'usize' {
            return i64(0)
        }
        'f32', 'f64' {
            return f64(0.0)
        }
        'string' {
            return ''
        }
        else {
            return e.zero_struct_value(type_name)
        }
    }
}

fn (e &Eval) zero_value_for_sumtype_data_field(data_type_name string, field_name string) ?Value {
    if !data_type_name.ends_with('._data') || !field_name.starts_with('_') {
        return none
    }
    parent_sumtype_name := data_type_name.all_before_last('._data')
    info := e.sum_type_info(parent_sumtype_name) or { return none }
    mut variant_alias := ''
    for alias in info.variant_tags.keys() {
        if '_' + e.sumtype_variant_field_name(alias) == field_name {
            variant_alias = e.canonical_sumtype_variant_name(info, alias)
            break
        }
    }
    if variant_alias == '' {
        return none
    }
    return e.zero_value_for_type_name(variant_alias)
}

fn (e &Eval) sumtype_variant_field_value(sum_value StructValue, field_name string) ?Value {
    if !field_name.starts_with('_') {
        return none
    }
    info := e.sum_type_info(sum_value.type_name) or { return none }
    tag_value := sum_value.fields['_tag'] or { return none }
    tag := int(e.value_as_int(tag_value) or { return none })
    mut variant_alias := ''
    mut variant_tag := -1
    for alias, alias_tag in info.variant_tags {
        if '_' + e.sumtype_variant_field_name(alias) == field_name {
            variant_alias = e.canonical_sumtype_variant_name(info, alias)
            variant_tag = alias_tag
            break
        }
    }
    if variant_alias == '' {
        return none
    }
    if tag == variant_tag {
        if payload := e.unwrap_sumtype_value(sum_value, variant_alias) {
            if !is_semantically_empty_value(payload) {
                return payload
            }
        }
    }
    return e.zero_value_for_type_name(variant_alias)
}

fn (e &Eval) infer_bare_sumtype_variant(info SumTypeInfo, value StructValue) ?InferredSumTypeVariant {
    if '_tag' in value.fields || '_data' in value.fields {
        return none
    }
    if value.fields.len == 0 {
        return none
    }
    mut matches := map[int]string{}
    for alias, tag in info.variant_tags {
        field_names := e.lookup_struct_field_names(alias) or { continue }
        if field_names.len != value.fields.len {
            continue
        }
        mut all_fields_match := true
        for field_name in value.fields.keys() {
            if field_name !in field_names {
                all_fields_match = false
                break
            }
        }
        if !all_fields_match {
            continue
        }
        if tag !in matches {
            matches[tag] = e.canonical_sumtype_variant_name(info, alias)
        }
    }
    if matches.len != 1 {
        return none
    }
    for tag, variant_name in matches {
        return InferredSumTypeVariant{
            tag:          tag
            variant_name: variant_name
        }
    }
    return none
}

fn (e &Eval) infer_nested_sumtype_variant(info SumTypeInfo, value Value) ?WrappedSumTypeVariant {
    for alias, tag in info.variant_tags {
        nested_info := e.sum_type_info(alias) or { continue }
        if nested_info.name == info.name && nested_info.module_name == info.module_name {
            continue
        }
        nested_payload := e.cast_value(value, alias) or { continue }
        match nested_payload {
            StructValue {
                if e.type_name_matches(nested_payload.type_name, alias)
                    && '_tag' in nested_payload.fields && '_data' in nested_payload.fields {
                    return WrappedSumTypeVariant{
                        tag:     tag
                        payload: nested_payload
                    }
                }
            }
            else {}
        }
    }
    return none
}

fn (e &Eval) sumtype_tag_from_value(info SumTypeInfo, value Value) ?int {
    match value {
        StructValue {
            if e.type_name_matches(value.type_name, '${info.module_name}.${info.name}') {
                if tag_value := value.fields['_tag'] {
                    return int(e.value_as_int(tag_value) or { return none })
                }
            }
            for alias in e.type_name_aliases(info.module_name, value.type_name) {
                if alias in info.variant_tags {
                    return info.variant_tags[alias]
                }
            }
            if inferred := e.infer_bare_sumtype_variant(info, value) {
                return inferred.tag
            }
        }
        string {
            return e.lookup_sumtype_variant_tag(info, 'string')
        }
        bool {
            return e.lookup_sumtype_variant_tag(info, 'bool')
        }
        i64 {
            for alias in ['int', 'i64', 'i32', 'i16', 'i8', 'u64', 'u32', 'u16', 'u8', 'byte',
                'char', 'rune'] {
                if tag := e.lookup_sumtype_variant_tag(info, alias) {
                    return tag
                }
            }
        }
        f64 {
            for alias in ['f64', 'f32'] {
                if tag := e.lookup_sumtype_variant_tag(info, alias) {
                    return tag
                }
            }
        }
        ArrayValue {
            mut tags := []int{}
            for alias, tag in info.variant_tags {
                if alias.starts_with('[]') && tag !in tags {
                    tags << tag
                }
            }
            if tags.len == 1 {
                return tags[0]
            }
        }
        MapValue {
            mut tags := []int{}
            for alias, tag in info.variant_tags {
                if alias.starts_with('map[') && tag !in tags {
                    tags << tag
                }
            }
            if tags.len == 1 {
                return tags[0]
            }
        }
        TypeValue {
            for alias in e.type_value_variant_aliases(info, value) {
                if alias in info.variant_tags {
                    return info.variant_tags[alias]
                }
            }
        }
        else {}
    }

    if nested := e.infer_nested_sumtype_variant(info, value) {
        return nested.tag
    }
    return none
}

fn (e &Eval) lookup_const_expr(module_name string, name string) ?ast.Expr {
    if module_name !in e.consts {
        return none
    }
    entry := e.consts[module_name][name] or { return none }
    if entry.expr is ast.EmptyExpr {
        return none
    }
    return entry.expr
}

fn (e &Eval) sumtype_variant_name_from_expr(expr ast.Expr) ?string {
    return e.sumtype_variant_name_from_expr_with_depth(expr, 0)
}

fn (e &Eval) sumtype_variant_name_from_expr_with_depth(expr ast.Expr, depth int) ?string {
    if depth > 8 {
        return none
    }
    return match expr {
        ast.ArrayInitExpr {
            if expr.typ is ast.EmptyExpr {
                none
            } else {
                e.type_expr_name(expr.typ)
            }
        }
        ast.BasicLiteral {
            match expr.kind {
                .key_false, .key_true {
                    'bool'
                }
                .char {
                    'char'
                }
                .number {
                    if expr.value.contains('.') || expr.value.contains('e')
                        || expr.value.contains('E') {
                        'f64'
                    } else {
                        'int'
                    }
                }
                else {
                    none
                }
            }
        }
        ast.CallOrCastExpr {
            if e.is_type_expr(expr.lhs) {
                e.type_expr_name(expr.lhs)
            } else {
                none
            }
        }
        ast.CastExpr {
            e.type_expr_name(expr.typ)
        }
        ast.InitExpr {
            e.type_expr_name(expr.typ)
        }
        ast.Ident {
            cur_module := e.current_module_name()
            if const_expr := e.lookup_const_expr(cur_module, expr.name) {
                e.sumtype_variant_name_from_expr_with_depth(const_expr, depth + 1)
            } else {
                if const_expr2 := e.lookup_const_expr('builtin', expr.name) {
                    e.sumtype_variant_name_from_expr_with_depth(const_expr2, depth + 1)
                } else {
                    none
                }
            }
        }
        ast.MapInitExpr {
            if expr.typ is ast.EmptyExpr {
                none
            } else {
                e.type_expr_name(expr.typ)
            }
        }
        ast.SelectorExpr {
            if expr.lhs is ast.Ident {
                module_name := e.resolve_module_name(expr.lhs.name)
                if module_name != '' {
                    if const_expr := e.lookup_const_expr(module_name, expr.rhs.name) {
                        e.sumtype_variant_name_from_expr_with_depth(const_expr, depth + 1)
                    } else {
                        none
                    }
                } else {
                    none
                }
            } else {
                none
            }
        }
        ast.StringInterLiteral, ast.StringLiteral {
            'string'
        }
        else {
            none
        }
    }
}

fn (e &Eval) build_sumtype_wrapper(type_name string, info SumTypeInfo, tag int, payload Value) StructValue {
    mut data_fields := map[string]Value{}
    mut field_aliases := []string{}
    if tag in info.tag_field_aliases {
        field_aliases = info.tag_field_aliases[tag]
    }
    for field_alias in field_aliases {
        data_fields[field_alias] = payload
    }
    return StructValue{
        type_name: type_name
        fields:    {
            '_tag':  Value(i64(tag))
            '_data': Value(StructValue{
                type_name: '${type_name}._data'
                fields:    data_fields
            })
        }
    }
}

fn (e &Eval) wrap_sumtype_value(sum_type_name string, value Value, expr ast.Expr) !Value {
    if value is StructValue && value.type_name == sum_type_name && '_tag' in value.fields
        && '_data' in value.fields {
        return value
    }
    info := e.sum_type_info(sum_type_name) or {
        return error('v2.eval: unknown sum type `${sum_type_name}`')
    }
    if value is StructValue {
        if inferred := e.infer_bare_sumtype_variant(info, value) {
            payload := StructValue{
                type_name: inferred.variant_name
                fields:    value.fields.clone()
            }
            return e.build_sumtype_wrapper(sum_type_name, info, inferred.tag, payload)
        }
    }
    if nested := e.infer_nested_sumtype_variant(info, value) {
        return e.build_sumtype_wrapper(sum_type_name, info, nested.tag, nested.payload)
    }
    if variant_name := e.sumtype_variant_name_from_expr(expr) {
        if tag := e.lookup_sumtype_variant_tag(info, variant_name) {
            return e.build_sumtype_wrapper(sum_type_name, info, tag, value)
        }
    }
    if tag := e.sumtype_tag_from_value(info, value) {
        return e.build_sumtype_wrapper(sum_type_name, info, tag, value)
    }
    return error('v2.eval: can not wrap `${e.runtime_type_name(value)}` into `${sum_type_name}` in `${e.current_function_label()}` stack `${e.call_stack_trace()}`')
}

fn (e &Eval) unwrap_sumtype_value(sum_value StructValue, target_type string) ?Value {
    info := e.sum_type_info(sum_value.type_name) or { return none }
    tag_value := sum_value.fields['_tag'] or { return none }
    tag := int(e.value_as_int(tag_value) or { return none })
    target_tag := e.lookup_sumtype_variant_tag(info, target_type) or { return none }
    if tag != target_tag {
        return none
    }
    data_value := sum_value.fields['_data'] or { return none }
    if data_value !is StructValue {
        return none
    }
    data_struct := data_value as StructValue
    mut field_aliases := []string{}
    if tag in info.tag_field_aliases {
        field_aliases = info.tag_field_aliases[tag]
    }
    for field_alias in field_aliases {
        for key, payload in data_struct.fields {
            if key == field_alias {
                return payload
            }
        }
    }
    for _, payload in data_struct.fields {
        return payload
    }
    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 'main.main'
    }
    frame := e.call_stack[e.call_stack.len - 1]
    return '${frame.module_name}.${frame.fn_name}'
}

fn (e &Eval) call_stack_trace() string {
    if e.call_stack.len == 0 {
        return 'main.main'
    }
    return e.call_stack.map('${it.module_name}.${it.fn_name}').join(' <- ')
}

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

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

fn (mut e Eval) writeback_mut_args(arg_exprs []ast.Expr, result CallResult) ! {
    for idx, value in result.mut_args {
        if idx < 0 || idx >= arg_exprs.len {
            continue
        }
        if can_update_target(arg_exprs[idx]) {
            e.update_target(arg_exprs[idx], value)!
        }
    }
}

fn (mut e Eval) call_function(module_name string, fn_name string, args []Value) !CallResult {
    if builtin_call_result := e.maybe_call_builtin_call_result(module_name, fn_name, args) {
        return builtin_call_result.result
    }
    builtin_result := e.maybe_call_builtin_function(module_name, fn_name, args)
    if builtin_result.found {
        return CallResult{
            values:   [builtin_result.value]
            mut_args: map[int]Value{}
        }
    }
    if target := e.resolve_mangled_function_target(fn_name) {
        return e.call_function(target.module_name, target.fn_name, args)
    }
    if module_name !in e.functions {
        return error('v2.eval: unknown module `${module_name}`')
    }
    def := e.functions[module_name][fn_name] or {
        return error('v2.eval: unknown function `${module_name}.${fn_name}`')
    }
    e.call_stack << CallFrame{
        module_name: module_name
        file_name:   def.file_name
        fn_name:     fn_name
    }
    defer {
        e.call_stack.pop()
    }
    scope_start := e.scopes.len
    e.open_scope()
    defer {
        for e.scopes.len > scope_start {
            e.close_scope() or {}
        }
    }
    has_receiver_arg := def.decl.is_method && !def.decl.is_static
    expected_args := def.decl.typ.params.len + if has_receiver_arg { 1 } else { 0 }
    if expected_args != args.len {
        return error('v2.eval: `${module_name}.${fn_name}` expected ${expected_args} arguments, got ${args.len}')
    }
    arg_offset := if has_receiver_arg { 1 } else { 0 }
    if has_receiver_arg && def.decl.receiver.name != '' && def.decl.receiver.name != '_' {
        receiver_value := if def.decl.receiver.typ is ast.EmptyExpr {
            args[0]
        } else {
            e.adapt_value_to_type(args[0], def.decl.receiver.typ)
        }
        e.declare_var(def.decl.receiver.name, receiver_value)
    }
    for i, param in def.decl.typ.params {
        param_value := if param.typ is ast.EmptyExpr {
            args[i + arg_offset]
        } else {
            e.adapt_value_to_type(args[i + arg_offset], param.typ)
        }
        e.declare_var(param.name, param_value)
    }
    signal := e.exec_stmts(def.decl.stmts)!
    mut returned_values := []Value{}
    if signal.kind == .return_ {
        returned_values = signal.values.clone()
    } else if signal.kind == .goto_ {
        return error('v2.eval: unknown goto label `${signal.label}`')
    } else if signal.kind != .normal {
        return error('v2.eval: unexpected `${signal.kind}` escaped `${module_name}.${fn_name}`')
    }
    if def.decl.typ.return_type is ast.Type {
        match def.decl.typ.return_type {
            ast.OptionType {
                if returned_values.len == 1 && is_option_value(returned_values[0]) {
                    return CallResult{
                        values:   [returned_values[0]]
                        mut_args: map[int]Value{}
                    }
                }
                if returned_values.len == 0
                    || (returned_values.len == 1 && returned_values[0] is VoidValue) {
                    return CallResult{
                        values:   [wrap_option_none()]
                        mut_args: map[int]Value{}
                    }
                }
                payload := if returned_values.len == 1 {
                    e.adapt_value_to_type(returned_values[0], def.decl.typ.return_type.base_type)
                } else {
                    Value(TupleValue{
                        values: returned_values
                    })
                }
                return CallResult{
                    values:   [wrap_option_ok(payload)]
                    mut_args: map[int]Value{}
                }
            }
            ast.ResultType {
                if returned_values.len == 1 && is_result_value(returned_values[0]) {
                    return CallResult{
                        values:   [returned_values[0]]
                        mut_args: map[int]Value{}
                    }
                }
                payload := if returned_values.len == 0 {
                    void_value()
                } else if returned_values.len == 1 {
                    e.adapt_value_to_type(returned_values[0], def.decl.typ.return_type.base_type)
                } else {
                    Value(TupleValue{
                        values: returned_values
                    })
                }
                return CallResult{
                    values:   [wrap_result_ok(payload)]
                    mut_args: map[int]Value{}
                }
            }
            else {}
        }
    }
    if returned_values.len == 1 && def.decl.typ.return_type !is ast.EmptyExpr {
        returned_values[0] = e.adapt_value_to_type(returned_values[0], def.decl.typ.return_type)
    }
    mut result := CallResult{
        values:   returned_values
        mut_args: map[int]Value{}
    }
    if has_receiver_arg && def.decl.receiver.is_mut && def.decl.receiver.name != ''
        && def.decl.receiver.name != '_' {
        receiver_value := e.lookup_var(def.decl.receiver.name)
        if receiver_value.found {
            result.mut_args[0] = receiver_value.value
        }
    }
    for i, param in def.decl.typ.params {
        if !param.is_mut || param.name == '' || param.name == '_' {
            continue
        }
        param_value := e.lookup_var(param.name)
        if param_value.found {
            result.mut_args[i + arg_offset] = param_value.value
        }
    }
    return result
}

fn (mut e Eval) maybe_call_builtin_call_result(module_name string, fn_name string, args []Value) ?MaybeCallResult {
    if module_name !in ['', 'builtin'] && !fn_name.starts_with('__Map_') {
        return none
    }
    if map_result := e.maybe_call_map_builtin_result(fn_name, args) {
        return map_result
    }
    return none
}

fn builtin_map_helper_matches(fn_name string, suffix string) bool {
    return fn_name == 'map__${suffix}' || fn_name.ends_with('map__${suffix}')
        || (fn_name.starts_with('__Map_') && fn_name.ends_with('_${suffix}'))
}

fn mut_call_result(value Value, index int, updated Value) CallResult {
    mut mut_args := map[int]Value{}
    mut_args[index] = updated
    return CallResult{
        values:   [value]
        mut_args: mut_args
    }
}

fn (mut e Eval) maybe_call_map_builtin_result(fn_name string, args []Value) ?MaybeCallResult {
    if args.len == 0 || args[0] !is MapValue {
        return none
    }
    receiver := args[0] as MapValue
    if builtin_map_helper_matches(fn_name, 'set') && args.len >= 3 {
        updated := e.map_set_value(receiver, args[1], args[2])
        return MaybeCallResult{
            found:  true
            result: mut_call_result(void_value(), 0, updated)
        }
    }
    if builtin_map_helper_matches(fn_name, 'get') && args.len >= 3 {
        value, found := e.map_lookup(receiver, args[1])
        return MaybeCallResult{
            found:  true
            result: CallResult{
                values:   [if found { value } else { args[2] }]
                mut_args: map[int]Value{}
            }
        }
    }
    if builtin_map_helper_matches(fn_name, 'get_and_set') && args.len >= 3 {
        value, found := e.map_lookup(receiver, args[1])
        if found {
            return MaybeCallResult{
                found:  true
                result: CallResult{
                    values:   [value]
                    mut_args: map[int]Value{}
                }
            }
        }
        updated := e.map_set_value(receiver, args[1], args[2])
        return MaybeCallResult{
            found:  true
            result: mut_call_result(args[2], 0, updated)
        }
    }
    if builtin_map_helper_matches(fn_name, 'exists') && args.len >= 2 {
        return MaybeCallResult{
            found:  true
            result: CallResult{
                values:   [e.map_contains_key(receiver, args[1])]
                mut_args: map[int]Value{}
            }
        }
    }
    if builtin_map_helper_matches(fn_name, 'delete') && args.len >= 2 {
        updated := e.map_delete_value(receiver, args[1])
        return MaybeCallResult{
            found:  true
            result: mut_call_result(void_value(), 0, updated)
        }
    }
    if builtin_map_helper_matches(fn_name, 'keys') {
        return MaybeCallResult{
            found:  true
            result: CallResult{
                values:   [e.map_keys(receiver)]
                mut_args: map[int]Value{}
            }
        }
    }
    if builtin_map_helper_matches(fn_name, 'values') {
        return MaybeCallResult{
            found:  true
            result: CallResult{
                values:   [e.map_values(receiver)]
                mut_args: map[int]Value{}
            }
        }
    }
    if builtin_map_helper_matches(fn_name, 'clone') {
        return MaybeCallResult{
            found:  true
            result: CallResult{
                values:   [e.map_clone(receiver)]
                mut_args: map[int]Value{}
            }
        }
    }
    if builtin_map_helper_matches(fn_name, 'clear') {
        return MaybeCallResult{
            found:  true
            result: mut_call_result(void_value(), 0, e.map_clear(receiver))
        }
    }
    if builtin_map_helper_matches(fn_name, 'move') {
        return MaybeCallResult{
            found:  true
            result: mut_call_result(receiver, 0, e.map_clear(receiver))
        }
    }
    return none
}

fn safe_arg(args []Value, idx int) Value {
    if idx < args.len {
        return args[idx]
    }
    return void_value()
}

fn builtin_method_name(fn_name string) string {
    if !fn_name.contains('__') {
        return fn_name
    }
    return fn_name.all_after_last('__')
}

fn builtin_receiver_name(fn_name string) string {
    if !fn_name.contains('__') {
        return ''
    }
    mut prefix := fn_name.all_before_last('__')
    if prefix.contains('__') {
        prefix = prefix.all_after_last('__')
    }
    return prefix
}

fn (e &Eval) expect_token_arg(args []Value, index int) !token.Token {
    raw := e.value_as_int(safe_arg(args, index))!
    // Enum values are stored as ints in eval, so host-side token helpers need a narrow cast here.
    return unsafe { token.Token(int(raw)) }
}

fn (e &Eval) expect_byte_arg(args []Value, index int) !u8 {
    raw := e.value_as_int(safe_arg(args, index))!
    return u8(raw)
}

fn (e &Eval) infer_array_elem_type(values []Value) string {
    if values.len == 0 {
        return ''
    }
    return e.runtime_type_name(values[0])
}

fn (e &Eval) array_elem_type_name(expr ast.Expr) string {
    return match expr {
        ast.Type {
            match expr {
                ast.ArrayType, ast.ArrayFixedType {
                    e.type_expr_name(expr.elem_type)
                }
                else {
                    ''
                }
            }
        }
        else {
            type_name := e.type_expr_name(expr)
            if type_name.starts_with('[]') {
                type_name[2..]
            } else if type_name.starts_with('[') && type_name.contains(']') {
                type_name.all_after(']')
            } else {
                ''
            }
        }
    }
}

fn (e &Eval) annotate_value_for_type(value Value, typ ast.Expr) Value {
    match value {
        ArrayValue {
            elem_type_name := if value.elem_type_name != '' {
                value.elem_type_name
            } else {
                e.array_elem_type_name(typ)
            }
            return ArrayValue{
                elem_type_name: elem_type_name
                values:         value.values
            }
        }
        else {
            return value
        }
    }
}

fn (e &Eval) is_existing_sumtype_wrapper(value Value, target_name string) bool {
    return match value {
        StructValue {
            e.type_name_matches(value.type_name, target_name)
        }
        else {
            false
        }
    }
}

fn (e &Eval) adapt_value_to_type_name(value Value, type_name string) Value {
    if type_name == '' {
        return value
    }
    if type_name.starts_with('?') {
        if is_option_value(value) {
            return value
        }
        if value is VoidValue {
            return wrap_option_none()
        }
        return wrap_option_ok(e.adapt_value_to_type_name(value, type_name[1..]))
    }
    if type_name.starts_with('!') {
        if is_result_value(value) {
            return value
        }
        return wrap_result_ok(e.adapt_value_to_type_name(value, type_name[1..]))
    }
    if type_name.starts_with('[]') && value is ArrayValue {
        array_value := value as ArrayValue
        return ArrayValue{
            elem_type_name: e.qualify_type_name(e.current_module_name(), type_name[2..])
            values:         array_value.values
        }
    }
    if e.is_sum_type_name(type_name) {
        if e.is_existing_sumtype_wrapper(value, type_name) {
            return value
        }
        return e.cast_value(value, type_name) or { value }
    }
    match type_name {
        'bool' {
            return e.value_as_bool(value) or { return value }
        }
        'byte', 'char', 'i8', 'i16', 'i32', 'int', 'i64', 'isize', 'rune', 'u8', 'u16', 'u32',
        'u64', 'usize' {
            return e.value_as_int(value) or { return value }
        }
        'f32', 'f64' {
            return e.value_as_f64(value) or { return value }
        }
        'string' {
            return e.value_string(value)
        }
        else {
            if value is StructValue {
                return e.cast_value(value, type_name) or { Value(value) }
            }
            return value
        }
    }
}

fn (e &Eval) adapt_value_to_type(value Value, typ ast.Expr) Value {
    adapted := e.annotate_value_for_type(value, typ)
    if typ is ast.Type {
        match typ {
            ast.OptionType {
                if is_option_value(adapted) {
                    return adapted
                }
                if adapted is VoidValue {
                    return wrap_option_none()
                }
                return wrap_option_ok(e.adapt_value_to_type(adapted, typ.base_type))
            }
            ast.ResultType {
                if is_result_value(adapted) {
                    return adapted
                }
                return wrap_result_ok(e.adapt_value_to_type(adapted, typ.base_type))
            }
            else {}
        }
    }
    target_name := e.type_expr_name(typ)
    if target_name != '' && e.is_sum_type_name(target_name) {
        if e.is_existing_sumtype_wrapper(adapted, target_name) {
            return adapted
        }
        return e.cast_value(adapted, target_name) or { adapted }
    }
    return adapted
}

fn (e &Eval) should_append_many(container ArrayValue, value ArrayValue) bool {
    if container.elem_type_name != '' && value.elem_type_name != '' {
        return container.elem_type_name == value.elem_type_name
    }
    if container.elem_type_name != '' && value.values.len > 0 {
        return container.elem_type_name == e.runtime_type_name(value.values[0])
    }
    if container.values.len > 0 && value.values.len > 0 {
        return e.runtime_type_name(container.values[0]) == e.runtime_type_name(value.values[0])
    }
    return false
}

fn (e &Eval) inferred_sumtype_tag(value Value) ?int {
    mut matches := map[string]int{}
    for _, info in e.sum_types {
        if tag := e.sumtype_tag_from_value(info, value) {
            key := '${info.module_name}.${info.name}:${tag}'
            matches[key] = tag
        }
    }
    if matches.len != 1 {
        return none
    }
    for _, tag in matches {
        return tag
    }
    return none
}

fn (mut e Eval) contextual_sumtype_tag(target_expr ast.Expr, value Value) ?int {
    match target_expr {
        ast.SelectorExpr {
            base := e.eval_expr(target_expr.lhs) or { return none }
            if base is StructValue {
                if field_type := e.lookup_struct_field_type(base.type_name, target_expr.rhs.name) {
                    target_name := e.type_expr_name(field_type)
                    if info := e.sum_type_info(target_name) {
                        return e.sumtype_tag_from_value(info, value)
                    }
                }
            }
        }
        ast.IndexExpr {
            container := e.eval_expr(target_expr.lhs) or { return none }
            match container {
                ArrayValue {
                    if info := e.sum_type_info(container.elem_type_name) {
                        return e.sumtype_tag_from_value(info, value)
                    }
                }
                MapValue {
                    if container.default_value is StructValue {
                        default_value := container.default_value as StructValue
                        if info := e.sum_type_info(default_value.type_name) {
                            return e.sumtype_tag_from_value(info, value)
                        }
                    }
                }
                else {}
            }
        }
        else {}
    }

    return none
}

fn eval_token_method_value(tok token.Token, method_name string) ?Value {
    return match method_name {
        'str' { Value(tok.str()) }
        'left_binding_power' { Value(i64(int(tok.left_binding_power()))) }
        'right_binding_power' { Value(i64(int(tok.right_binding_power()))) }
        'is_keyword' { Value(tok.is_keyword()) }
        'is_prefix' { Value(tok.is_prefix()) }
        'is_infix' { Value(tok.is_infix()) }
        'is_postfix' { Value(tok.is_postfix()) }
        'is_assignment' { Value(tok.is_assignment()) }
        'is_overloadable' { Value(tok.is_overloadable()) }
        'is_comparison' { Value(tok.is_comparison()) }
        else { none }
    }
}

fn eval_byte_method_value(c u8, method_name string) ?Value {
    return match method_name {
        'is_space' {
            Value(c == 32 || (c > 8 && c < 14) || c == 0x85 || c == 0xa0)
        }
        'is_digit' {
            Value(c >= `0` && c <= `9`)
        }
        'is_hex_digit' {
            Value((c >= `0` && c <= `9`) || (c >= `a` && c <= `f`) || (c >= `A` && c <= `F`))
        }
        'is_oct_digit' {
            Value(c >= `0` && c <= `7`)
        }
        'is_bin_digit' {
            Value(c == `0` || c == `1`)
        }
        'is_letter' {
            Value((c >= `a` && c <= `z`) || (c >= `A` && c <= `Z`))
        }
        'is_alnum' {
            Value((c >= `a` && c <= `z`) || (c >= `A` && c <= `Z`) || (c >= `0` && c <= `9`))
        }
        'is_capital' {
            Value(c >= `A` && c <= `Z`)
        }
        else {
            none
        }
    }
}

fn (e &Eval) maybe_call_token_builtin(fn_name string, args []Value) MaybeValue {
    method_name := builtin_method_name(fn_name)
    receiver_name := builtin_receiver_name(fn_name)
    if receiver_name == 'Token' {
        tok := e.expect_token_arg(args, 0) or { return MaybeValue{} }
        if value := eval_token_method_value(tok, method_name) {
            return MaybeValue{
                found: true
                value: value
            }
        }
        return MaybeValue{}
    }
    if method_name == 'from_string_tinyv' && receiver_name in ['', 'Token'] {
        name := e.expect_string_arg(args, args.len - 1) or { return MaybeValue{} }
        return MaybeValue{
            found: true
            value: i64(int(token.Token.from_string_tinyv(name)))
        }
    }
    return MaybeValue{}
}

fn (e &Eval) maybe_call_ast_builtin(fn_name string, args []Value) MaybeValue {
    method_name := builtin_method_name(fn_name)
    receiver_name := builtin_receiver_name(fn_name)
    if receiver_name in ['', 'StringLiteralKind'] {
        match method_name {
            'str' {
                raw := e.value_as_int(safe_arg(args, 0)) or { return MaybeValue{} }
                // StringLiteralKind is stored as an int in eval and only used with known enum values here.
                kind := unsafe { ast.StringLiteralKind(int(raw)) }
                return MaybeValue{
                    found: true
                    value: kind.str()
                }
            }
            'from_string_tinyv' {
                name := e.expect_string_arg(args, args.len - 1) or { return MaybeValue{} }
                return MaybeValue{
                    found: true
                    value: i64(int(ast.StringLiteralKind.from_string_tinyv(name)))
                }
            }
            else {}
        }
    }
    return MaybeValue{}
}

fn (e &Eval) maybe_call_byte_builtin(module_name string, fn_name string, args []Value) MaybeValue {
    if module_name !in ['', 'builtin'] {
        return MaybeValue{}
    }
    receiver_name := builtin_receiver_name(fn_name)
    if receiver_name !in ['u8', 'byte'] {
        return MaybeValue{}
    }
    c := e.expect_byte_arg(args, 0) or { return MaybeValue{} }
    if value := eval_byte_method_value(c, builtin_method_name(fn_name)) {
        return MaybeValue{
            found: true
            value: value
        }
    }
    return MaybeValue{}
}

fn is_semantically_empty_value(value Value) bool {
    return match value {
        VoidValue {
            true
        }
        StructValue {
            for field_value in value.fields.values() {
                if !is_semantically_empty_value(field_value) {
                    return false
                }
            }
            true
        }
        else {
            false
        }
    }
}

fn (e &Eval) type_sum_data_is_nil(value Value) bool {
    match value {
        StructValue {
            if '_data' !in value.fields {
                return false
            }
            data_value := value.fields['_data'] or { return false }
            return is_semantically_empty_value(data_value)
        }
        TypeValue {
            return false
        }
        else {
            return is_semantically_empty_value(value)
        }
    }
}

fn has_flag_bit(bits i64, flag i64) bool {
    return (bits & flag) != 0
}

fn (e &Eval) primitive_type_name(value StructValue) string {
    props := e.value_as_int(value.fields['props'] or { Value(i64(0)) }) or { 0 }
    size := e.value_as_int(value.fields['size'] or { Value(i64(0)) }) or { 0 }
    if has_flag_bit(props, 1) {
        return 'bool'
    }
    if has_flag_bit(props, 16) {
        if has_flag_bit(props, 4) {
            return 'int_literal'
        }
        if has_flag_bit(props, 2) {
            return 'float_literal'
        }
    }
    if has_flag_bit(props, 2) {
        return if size == 32 { 'f32' } else { 'f64' }
    }
    if has_flag_bit(props, 4) {
        if has_flag_bit(props, 8) {
            return match size {
                8 { 'u8' }
                16 { 'u16' }
                32 { 'u32' }
                64 { 'u64' }
                else { 'u64' }
            }
        }
        return match size {
            8 { 'i8' }
            16 { 'i16' }
            32 { 'i32' }
            64 { 'i64' }
            else { 'int' }
        }
    }
    return 'int'
}

fn (e &Eval) option_payload_type_name(value Value) string {
    if !is_option_value(value) || value !is StructValue {
        return ''
    }
    option_value := value as StructValue
    state := e.value_as_int(option_value.fields['state'] or { Value(i64(1)) }) or { 1 }
    if state != 0 {
        return ''
    }
    return e.types_value_name(option_value.fields['data'] or { return '' })
}

fn (e &Eval) tuple_type_name(value StructValue) string {
    if types_value := value.fields['types'] {
        if types_value is ArrayValue {
            return '(' + types_value.values.map(e.types_value_name(it)).join(',') + ')'
        }
    }
    return '()'
}

fn (e &Eval) sumtype_payload_name(value StructValue) string {
    data_value := value.fields['_data'] or { return 'void' }
    if data_value is StructValue {
        data_struct := data_value as StructValue
        if tag_value := value.fields['_tag'] {
            tag := int(e.value_as_int(tag_value) or { -1 })
            if info := e.sum_type_info(value.type_name) {
                if field_aliases := info.tag_field_aliases[tag] {
                    for field_alias in field_aliases {
                        if payload := data_struct.fields[field_alias] {
                            return e.types_value_name(payload)
                        }
                    }
                }
            }
        }
        for payload in data_struct.fields.values() {
            if !is_semantically_empty_value(payload) {
                return e.types_value_name(payload)
            }
        }
        for payload in data_struct.fields.values() {
            return e.types_value_name(payload)
        }
    }
    return 'void'
}

fn (e &Eval) types_value_name(value Value) string {
    return match value {
        StructValue {
            mut short_name := value.type_name.all_after_last('.')
            if short_name.contains('__') {
                short_name = short_name.all_after_last('__')
            }
            match short_name {
                'Type' {
                    e.sumtype_payload_name(value)
                }
                'Primitive' {
                    e.primitive_type_name(value)
                }
                'Alias' {
                    name_value := value.fields['name'] or { Value('') }
                    name := e.value_string(name_value)
                    if name != '' {
                        name
                    } else if base_type := value.fields['base_type'] {
                        e.types_value_name(base_type)
                    } else {
                        'alias'
                    }
                }
                'Array' {
                    elem_type := value.fields['elem_type'] or { return '[]void' }
                    '[]' + e.types_value_name(elem_type)
                }
                'ArrayFixed' {
                    len_value := value.fields['len'] or { return '[0]void' }
                    elem_type := value.fields['elem_type'] or { return '[0]void' }
                    '[${e.value_as_int(len_value) or { 0 }}]${e.types_value_name(elem_type)}'
                }
                'Channel' {
                    elem_type_name := e.option_payload_type_name(value.fields['elem_type'] or {
                        return 'chan'
                    })
                    if elem_type_name == '' {
                        'chan'
                    } else {
                        'chan ${elem_type_name}'
                    }
                }
                'Char' {
                    'char'
                }
                'Enum', 'Interface', 'Struct', 'SumType' {
                    e.value_string(value.fields['name'] or { Value(short_name.to_lower()) })
                }
                'FnType' {
                    'fn'
                }
                'ISize' {
                    'isize'
                }
                'Map' {
                    key_type := value.fields['key_type'] or { return 'map[void]void' }
                    value_type := value.fields['value_type'] or { return 'map[void]void' }
                    'map[${e.types_value_name(key_type)}]${e.types_value_name(value_type)}'
                }
                'None' {
                    'none'
                }
                'OptionType' {
                    base_type := value.fields['base_type'] or { return '?void' }
                    '?' + e.types_value_name(base_type)
                }
                'Pointer' {
                    base_type := value.fields['base_type'] or { return '&void' }
                    '&' + e.types_value_name(base_type)
                }
                'ResultType' {
                    base_type := value.fields['base_type'] or { return '!void' }
                    '!' + e.types_value_name(base_type)
                }
                'Rune' {
                    'rune'
                }
                'String' {
                    'string'
                }
                'Thread' {
                    elem_type_name := e.option_payload_type_name(value.fields['elem_type'] or {
                        return 'thread'
                    })
                    if elem_type_name == '' {
                        'thread'
                    } else {
                        'thread ${elem_type_name}'
                    }
                }
                'Tuple' {
                    e.tuple_type_name(value)
                }
                'USize' {
                    'usize'
                }
                'Void' {
                    'void'
                }
                'Nil' {
                    'nil'
                }
                else {
                    e.value_string(value.fields['name'] or { Value(short_name) })
                }
            }
        }
        TypeValue {
            mut short_name := value.name.all_after_last('.')
            if short_name.contains('__') {
                short_name = short_name.all_after_last('__')
            }
            short_name
        }
        else {
            e.runtime_type_name(value)
        }
    }
}

fn (mut e Eval) maybe_call_builtin_function(module_name string, fn_name string, args []Value) MaybeValue {
    if fn_name == 'free' || fn_name.ends_with('__free') {
        return MaybeValue{
            found: true
            value: void_value()
        }
    }
    if fn_name == 'type_data_ptr_is_nil' || fn_name.ends_with('__type_data_ptr_is_nil')
        || fn_name == 'type_has_null_data' || fn_name.ends_with('__type_has_null_data') {
        return MaybeValue{
            found: true
            value: e.type_sum_data_is_nil(safe_arg(args, 0))
        }
    }
    if module_name == 'types'
        && (fn_name == 'type_name' || fn_name == 'Type__name' || fn_name.ends_with('Type__name')) {
        return MaybeValue{
            found: true
            value: e.types_value_name(safe_arg(args, 0))
        }
    }
    if fn_name == 'map__get_check' || fn_name.ends_with('map__get_check')
        || (fn_name.starts_with('__Map_') && fn_name.ends_with('_get_check')) {
        if args.len >= 2 && args[0] is MapValue {
            map_value := args[0] as MapValue
            value, found := e.map_lookup(map_value, args[1])
            return MaybeValue{
                found: true
                value: if found { value } else { void_value() }
            }
        }
    }
    if fn_name in ['sync__RwMutex_lock', 'sync__RwMutex_unlock', 'sync__RwMutex_rlock', 'sync__RwMutex_runlock']
        || fn_name.ends_with('RwMutex_lock') || fn_name.ends_with('RwMutex_unlock')
        || fn_name.ends_with('RwMutex_rlock') || fn_name.ends_with('RwMutex_runlock') {
        return MaybeValue{
            found: true
            value: void_value()
        }
    }
    if module_name == 'token' {
        token_result := e.maybe_call_token_builtin(fn_name, args)
        if token_result.found {
            return token_result
        }
    }
    if module_name == 'ast' {
        ast_result := e.maybe_call_ast_builtin(fn_name, args)
        if ast_result.found {
            return ast_result
        }
    }
    if fn_name.ends_with('__str') && args.len == 1 {
        return MaybeValue{
            found: true
            value: e.value_string(args[0])
        }
    }
    if fn_name.ends_with('__eq') && args.len == 2 {
        return MaybeValue{
            found: true
            value: e.value_eq(args[0], args[1])
        }
    }
    if fn_name.starts_with('string__') && args.len >= 1 {
        receiver := e.value_string(args[0])
        method_name := fn_name.all_after('string__')
        if result := e.call_string_method(receiver, method_name, args[1..]) {
            return MaybeValue{
                found: true
                value: result
            }
        }
    }
    if array_helper := e.maybe_call_generated_array_helper(fn_name, args) {
        return array_helper
    }
    byte_result := e.maybe_call_byte_builtin(module_name, fn_name, args)
    if byte_result.found {
        return byte_result
    }
    if fn_name in ['builtin__new_array_from_c_array_noscan', 'builtin__new_array_from_c_array', 'new_array_from_c_array_noscan', 'new_array_from_c_array']
        && args.len >= 4 {
        mut values := []Value{}
        if args[3] is ArrayValue {
            array_arg := args[3] as ArrayValue
            values = array_arg.values.clone()
        } else if args[3] is string {
            string_arg := args[3] as string
            for b in string_arg.bytes() {
                values << i64(b)
            }
        }
        target_len := int(e.value_as_int(args[0]) or { values.len })
        if target_len >= 0 && target_len < values.len {
            values = values[..target_len].clone()
        }
        return MaybeValue{
            found: true
            value: ArrayValue{
                values: values
            }
        }
    }
    if fn_name == '__new_array_with_default_noscan' && args.len >= 4 {
        target_len := int(e.value_as_int(args[0]) or { 0 })
        init_value := args[3]
        mut values := []Value{cap: target_len}
        for _ in 0 .. target_len {
            values << init_value
        }
        return MaybeValue{
            found: true
            value: ArrayValue{
                values: values
            }
        }
    }
    if module_name in ['', 'builtin'] {
        match fn_name {
            'arguments' {
                return MaybeValue{
                    found: true
                    value: ArrayValue{
                        values: e.program_args().map(Value(it))
                    }
                }
            }
            'array__slice' {
                if args.len < 3 || args[0] !is ArrayValue {
                    return MaybeValue{}
                }
                arr := args[0] as ArrayValue
                start := int(e.value_as_int(args[1]) or { return MaybeValue{} })
                end := int(e.value_as_int(args[2]) or { return MaybeValue{} })
                return MaybeValue{
                    found: true
                    value: ArrayValue{
                        values: arr.values[start..end]
                    }
                }
            }
            'print' {
                e.write_stdout(e.value_string(safe_arg(args, 0)))
                return MaybeValue{
                    found: true
                    value: void_value()
                }
            }
            'println' {
                e.write_stdout(e.value_string(safe_arg(args, 0)) + '\n')
                return MaybeValue{
                    found: true
                    value: void_value()
                }
            }
            'eprint' {
                e.write_stderr(e.value_string(safe_arg(args, 0)))
                return MaybeValue{
                    found: true
                    value: void_value()
                }
            }
            'eprintln' {
                e.write_stderr(e.value_string(safe_arg(args, 0)) + '\n')
                return MaybeValue{
                    found: true
                    value: void_value()
                }
            }
            'panic' {
                panic(e.value_string(safe_arg(args, 0)))
            }
            else {}
        }
    }
    if module_name == 'token' && fn_name.ends_with('File__pos') && args.len >= 2 {
        offset := e.value_as_int(args[1]) or { return MaybeValue{} }
        mut base := i64(0)
        mut size := i64(0)
        if args[0] is StructValue {
            file := args[0] as StructValue
            if base_value := file.fields['base'] {
                base = e.value_as_int(base_value) or { 0 }
            }
            if size_value := file.fields['size'] {
                size = e.value_as_int(size_value) or { 0 }
            }
        }
        if offset > size {
            return MaybeValue{}
        }
        e.next_token_pos_id++
        return MaybeValue{
            found: true
            value: StructValue{
                type_name: 'token__Pos'
                fields:    {
                    'offset': Value(base + offset)
                    'id':     Value(e.next_token_pos_id)
                }
            }
        }
    }
    if module_name == 'os' {
        match fn_name {
            'execute' {
                cmd := e.expect_string_arg(args, 0) or { return MaybeValue{} }
                return MaybeValue{
                    found: true
                    value: os_result_value(os.execute(cmd))
                }
            }
            'execute_opt' {
                cmd := e.expect_string_arg(args, 0) or { return MaybeValue{} }
                res := os.execute(cmd)
                if res.exit_code != 0 {
                    return MaybeValue{
                        found: true
                        value: wrap_result_err(res.output)
                    }
                }
                return MaybeValue{
                    found: true
                    value: wrap_result_ok(os_result_value(res))
                }
            }
            'arguments' {
                return MaybeValue{
                    found: true
                    value: ArrayValue{
                        values: e.program_args().map(Value(it))
                    }
                }
            }
            'dir' {
                return MaybeValue{
                    found: true
                    value: os.dir(e.expect_string_arg(args, 0) or { return MaybeValue{} })
                }
            }
            'file_name' {
                return MaybeValue{
                    found: true
                    value: os.file_name(e.expect_string_arg(args, 0) or { return MaybeValue{} })
                }
            }
            'join_path' {
                mut parts := e.array_args_to_strings(args)
                if parts.len == 0 {
                    return MaybeValue{
                        found: true
                        value: ''
                    }
                }
                mut joined := parts[0]
                for part in parts[1..] {
                    joined = os.join_path(joined, part)
                }
                return MaybeValue{
                    found: true
                    value: joined
                }
            }
            'exists' {
                return MaybeValue{
                    found: true
                    value: os.exists(e.expect_string_arg(args, 0) or { return MaybeValue{} })
                }
            }
            'is_dir' {
                return MaybeValue{
                    found: true
                    value: os.is_dir(e.expect_string_arg(args, 0) or { return MaybeValue{} })
                }
            }
            'getwd' {
                return MaybeValue{
                    found: true
                    value: os.getwd()
                }
            }
            'temp_dir' {
                return MaybeValue{
                    found: true
                    value: os.temp_dir()
                }
            }
            'getenv' {
                return MaybeValue{
                    found: true
                    value: os.getenv(e.expect_string_arg(args, 0) or { return MaybeValue{} })
                }
            }
            'getenv_opt' {
                key := e.expect_string_arg(args, 0) or { return MaybeValue{} }
                if value := os.getenv_opt(key) {
                    return MaybeValue{
                        found: true
                        value: wrap_option_ok(value)
                    }
                }
                return MaybeValue{
                    found: true
                    value: wrap_option_none()
                }
            }
            'is_abs_path' {
                return MaybeValue{
                    found: true
                    value: os.is_abs_path(e.expect_string_arg(args, 0) or { return MaybeValue{} })
                }
            }
            'norm_path' {
                return MaybeValue{
                    found: true
                    value: os.norm_path(e.expect_string_arg(args, 0) or { return MaybeValue{} })
                }
            }
            'real_path' {
                return MaybeValue{
                    found: true
                    value: os.real_path(e.expect_string_arg(args, 0) or { return MaybeValue{} })
                }
            }
            'quoted_path' {
                return MaybeValue{
                    found: true
                    value: os.quoted_path(e.expect_string_arg(args, 0) or { return MaybeValue{} })
                }
            }
            'base' {
                return MaybeValue{
                    found: true
                    value: os.base(e.expect_string_arg(args, 0) or { return MaybeValue{} })
                }
            }
            'user_os' {
                return MaybeValue{
                    found: true
                    value: os.user_os()
                }
            }
            'ls' {
                path := e.expect_string_arg(args, 0) or { return MaybeValue{} }
                if path == '' {
                    return MaybeValue{
                        found: true
                        value: wrap_result_err('os.ls empty path in `${e.current_function_label()}` stack `${e.call_stack_trace()}`')
                    }
                }
                items := os.ls(path) or {
                    return MaybeValue{
                        found: true
                        value: wrap_result_err(err.msg())
                    }
                }
                return MaybeValue{
                    found: true
                    value: wrap_result_ok(ArrayValue{
                        values: items.map(Value(it))
                    })
                }
            }
            'read_file' {
                path := e.expect_string_arg(args, 0) or { return MaybeValue{} }
                if path == '' {
                    return MaybeValue{
                        found: true
                        value: wrap_result_err('os.read_file empty path in `${e.current_function_label()}` stack `${e.call_stack_trace()}`')
                    }
                }
                content := os.read_file(path) or {
                    return MaybeValue{
                        found: true
                        value: wrap_result_err(err.msg())
                    }
                }
                return MaybeValue{
                    found: true
                    value: wrap_result_ok(content)
                }
            }
            'read_lines' {
                path := e.expect_string_arg(args, 0) or { return MaybeValue{} }
                lines := os.read_lines(path) or {
                    return MaybeValue{
                        found: true
                        value: wrap_result_err(err.msg())
                    }
                }
                return MaybeValue{
                    found: true
                    value: wrap_result_ok(ArrayValue{
                        elem_type_name: 'string'
                        values:         lines.map(Value(it))
                    })
                }
            }
            'read_bytes' {
                path := e.expect_string_arg(args, 0) or { return MaybeValue{} }
                bytes := os.read_bytes(path) or {
                    return MaybeValue{
                        found: true
                        value: wrap_result_err(err.msg())
                    }
                }
                return MaybeValue{
                    found: true
                    value: wrap_result_ok(ArrayValue{
                        elem_type_name: 'u8'
                        values:         bytes.map(Value(i64(it)))
                    })
                }
            }
            'write_file' {
                os.write_file(e.expect_string_arg(args, 0) or { return MaybeValue{} }, e.expect_string_arg(args,
                    1) or { return MaybeValue{} }) or {
                    return MaybeValue{
                        found: true
                        value: wrap_result_err(err.msg())
                    }
                }
                return MaybeValue{
                    found: true
                    value: wrap_result_ok(void_value())
                }
            }
            'write_file_array' {
                path := e.expect_string_arg(args, 0) or { return MaybeValue{} }
                bytes := e.value_to_byte_array(safe_arg(args, 1)) or { return MaybeValue{} }
                os.write_file_array(path, bytes) or {
                    return MaybeValue{
                        found: true
                        value: wrap_result_err(err.msg())
                    }
                }
                return MaybeValue{
                    found: true
                    value: wrap_result_ok(void_value())
                }
            }
            'mkdir_all' {
                path := e.expect_string_arg(args, 0) or { return MaybeValue{} }
                os.mkdir_all(path) or {
                    return MaybeValue{
                        found: true
                        value: wrap_result_err(err.msg())
                    }
                }
                return MaybeValue{
                    found: true
                    value: wrap_result_ok(void_value())
                }
            }
            'rmdir_all' {
                path := e.expect_string_arg(args, 0) or { return MaybeValue{} }
                os.rmdir_all(path) or {
                    return MaybeValue{
                        found: true
                        value: wrap_result_err(err.msg())
                    }
                }
                return MaybeValue{
                    found: true
                    value: wrap_result_ok(void_value())
                }
            }
            'rm' {
                os.rm(e.expect_string_arg(args, 0) or { return MaybeValue{} }) or {
                    return MaybeValue{
                        found: true
                        value: wrap_result_err(err.msg())
                    }
                }
                return MaybeValue{
                    found: true
                    value: wrap_result_ok(void_value())
                }
            }
            'cp' {
                os.cp(e.expect_string_arg(args, 0) or { return MaybeValue{} }, e.expect_string_arg(args,
                    1) or { return MaybeValue{} }) or {
                    return MaybeValue{
                        found: true
                        value: wrap_result_err(err.msg())
                    }
                }
                return MaybeValue{
                    found: true
                    value: wrap_result_ok(void_value())
                }
            }
            else {}
        }
    }
    if module_name == 'time' {
        match fn_name {
            'sys_mono_now', 'sys_mono_now_darwin', 'vpc_now', 'vpc_now_darwin' {
                return MaybeValue{
                    found: true
                    value: i64(time.now().unix_micro() * 1000)
                }
            }
            else {}
        }
    }
    if module_name == 'token' {
        match fn_name {
            'File__line_start', 'line_start' {
                if args.len < 2 || args[0] !is StructValue {
                    return MaybeValue{}
                }
                file_value := args[0] as StructValue
                line := int(e.value_as_int(args[1]) or { return MaybeValue{} })
                if line <= 0 {
                    return MaybeValue{
                        found: true
                        value: i64(0)
                    }
                }
                line_offsets := file_value.fields['line_offsets'] or { return MaybeValue{} }
                if line_offsets !is ArrayValue {
                    return MaybeValue{}
                }
                offsets := line_offsets as ArrayValue
                idx := line - 1
                if idx < 0 || idx >= offsets.values.len {
                    return MaybeValue{
                        found: true
                        value: i64(0)
                    }
                }
                return MaybeValue{
                    found: true
                    value: offsets.values[idx]
                }
            }
            else {}
        }
    }
    if module_name == 'cmdline' {
        match fn_name {
            'option' {
                if args.len < 1 {
                    return MaybeValue{}
                }
                str_arr := e.value_to_string_array(args[0]) or { return MaybeValue{} }
                opt_arg1 := e.expect_string_arg(args, 1) or { return MaybeValue{} }
                opt_arg2 := e.expect_string_arg(args, 2) or { return MaybeValue{} }
                return MaybeValue{
                    found: true
                    value: host_cmdline.option(str_arr, opt_arg1, opt_arg2)
                }
            }
            'options' {
                if args.len < 1 {
                    return MaybeValue{}
                }
                str_arr := e.value_to_string_array(args[0]) or { return MaybeValue{} }
                opt_arg1 := e.expect_string_arg(args, 1) or { return MaybeValue{} }
                return MaybeValue{
                    found: true
                    value: ArrayValue{
                        values: host_cmdline.options(str_arr, opt_arg1).map(Value(it))
                    }
                }
            }
            'only_options' {
                if args.len < 1 {
                    return MaybeValue{}
                }
                str_arr := e.value_to_string_array(args[0]) or { return MaybeValue{} }
                return MaybeValue{
                    found: true
                    value: ArrayValue{
                        values: host_cmdline.only_options(str_arr).map(Value(it))
                    }
                }
            }
            else {}
        }
    }
    return MaybeValue{}
}

fn (e &Eval) clone_array_item_to_depth(value Value, depth int) Value {
    if depth < 0 {
        return value
    }
    return match value {
        ArrayValue {
            e.clone_array_to_depth(value, depth)
        }
        string {
            value.clone()
        }
        else {
            value
        }
    }
}

fn (e &Eval) clone_array_to_depth(array_value ArrayValue, depth int) ArrayValue {
    if depth <= 0 {
        return ArrayValue{
            elem_type_name: array_value.elem_type_name
            values:         array_value.values.clone()
        }
    }
    mut values := []Value{cap: array_value.values.len}
    for item in array_value.values {
        values << e.clone_array_item_to_depth(item, depth - 1)
    }
    return ArrayValue{
        elem_type_name: array_value.elem_type_name
        values:         values
    }
}

fn (mut e Eval) maybe_call_generated_array_helper(fn_name string, args []Value) ?MaybeValue {
    if args.len > 0 && args[0] is ArrayValue {
        array_value := args[0] as ArrayValue
        if fn_name == 'array__first' || fn_name.ends_with('array__first') {
            return MaybeValue{
                found: true
                value: e.array_first_value(array_value) or { return none }
            }
        }
        if fn_name == 'array__last' || fn_name.ends_with('array__last') {
            return MaybeValue{
                found: true
                value: e.array_last_value(array_value) or { return none }
            }
        }
        if fn_name == 'array__clone' || fn_name.ends_with('array__clone') {
            return MaybeValue{
                found: true
                value: e.clone_array_to_depth(array_value, 0)
            }
        }
        if (fn_name == 'array__clone_to_depth' || fn_name.ends_with('array__clone_to_depth'))
            && args.len >= 2 {
            depth := int(e.value_as_int(args[1]) or { return none })
            return MaybeValue{
                found: true
                value: e.clone_array_to_depth(array_value, depth)
            }
        }
    }
    if !fn_name.starts_with('Array_') || args.len == 0 || args[0] !is ArrayValue {
        return none
    }
    array_value := args[0] as ArrayValue
    if fn_name.ends_with('_first') {
        return MaybeValue{
            found: true
            value: e.array_first_value(array_value) or { return none }
        }
    }
    if fn_name.ends_with('_last') {
        return MaybeValue{
            found: true
            value: e.array_last_value(array_value) or { return none }
        }
    }
    if fn_name.ends_with('_contains') && args.len >= 2 {
        return MaybeValue{
            found: true
            value: e.array_contains(array_value, args[1])
        }
    }
    if fn_name.ends_with('_has') && args.len >= 2 {
        return MaybeValue{
            found: true
            value: e.array_has(array_value, args[1])
        }
    }
    if fn_name.ends_with('_index') && !fn_name.ends_with('_last_index') && args.len >= 2 {
        return MaybeValue{
            found: true
            value: e.array_index(array_value, args[1], false)
        }
    }
    if fn_name.ends_with('_last_index') && args.len >= 2 {
        return MaybeValue{
            found: true
            value: e.array_index(array_value, args[1], true)
        }
    }
    if fn_name.ends_with('_join') && args.len >= 2 {
        return MaybeValue{
            found: true
            value: array_value.values.map(e.value_string(it)).join(e.expect_string_arg(args, 1) or {
                return none
            })
        }
    }
    if fn_name.ends_with('_str') {
        return MaybeValue{
            found: true
            value: e.value_string(array_value)
        }
    }
    return none
}

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

fn (mut e Eval) close_scope() ! {
    if e.scopes.len == 0 {
        return
    }
    scope_idx := e.scopes.len - 1
    defers := e.scopes[scope_idx].defers.clone()
    for i := defers.len - 1; i >= 0; i-- {
        signal := e.exec_stmts(defers[i])!
        if signal.kind != .normal {
            return error('v2.eval: control flow inside defer is not supported')
        }
    }
    e.scopes.pop()
}

fn (mut e Eval) declare_var(name string, value Value) {
    if name == '' || name == '_' {
        return
    }
    if e.scopes.len == 0 {
        e.open_scope()
    }
    e.scopes[e.scopes.len - 1].vars[name] = value
}

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

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

fn (mut e Eval) exec_stmts(stmts []ast.Stmt) !FlowSignal {
    mut label_positions := map[string]int{}
    for i, stmt in stmts {
        if stmt is ast.LabelStmt {
            label_positions[stmt.name] = i
        }
    }
    mut i := 0
    for i < stmts.len {
        stmt := stmts[i]
        signal := e.exec_stmt(stmt)!
        if signal.kind == .goto_ {
            if signal.label in label_positions {
                i = label_positions[signal.label]
                continue
            }
            return signal
        }
        if signal.kind != .normal {
            return signal
        }
        i++
    }
    return FlowSignal{
        kind: .normal
    }
}

fn (mut e Eval) exec_block(stmts []ast.Stmt) !FlowSignal {
    e.open_scope()
    signal := e.exec_stmts(stmts)!
    e.close_scope()!
    return signal
}

fn (mut e Eval) exec_stmt(stmt ast.Stmt) !FlowSignal {
    match stmt {
        ast.AssertStmt {
            passed := e.value_as_bool(e.eval_expr(stmt.expr)!)!
            if !passed {
                message := if stmt.extra is ast.EmptyExpr {
                    'assertion failed'
                } else {
                    e.value_string(e.eval_expr(stmt.extra)!)
                }
                return error('v2.eval: ${message}')
            }
        }
        ast.AssignStmt {
            return e.exec_assign_stmt(stmt)
        }
        ast.BlockStmt {
            return e.exec_block(stmt.stmts)
        }
        ast.ComptimeStmt {
            return e.exec_stmt(stmt.stmt)
        }
        ast.DeferStmt {
            if e.scopes.len == 0 {
                return error('v2.eval: defer used outside of a scope')
            }
            e.scopes[e.scopes.len - 1].defers << stmt.stmts
        }
        ast.ExprStmt {
            return e.exec_expr_stmt(stmt.expr)
        }
        ast.FlowControlStmt {
            return match stmt.op {
                .key_break {
                    FlowSignal{
                        kind: .break_
                    }
                }
                .key_continue {
                    FlowSignal{
                        kind: .continue_
                    }
                }
                .key_goto {
                    FlowSignal{
                        kind:  .goto_
                        label: stmt.label
                    }
                }
                else {
                    return error('v2.eval: unsupported flow control `${stmt.op}`')
                }
            }
        }
        ast.ForStmt {
            return e.exec_for_stmt(stmt)
        }
        ast.ReturnStmt {
            mut values := []Value{cap: stmt.exprs.len}
            for expr in stmt.exprs {
                values << e.eval_expr(expr)!
            }
            return FlowSignal{
                kind:   .return_
                values: values
            }
        }
        ast.ConstDecl, ast.Directive, ast.EnumDecl, ast.FnDecl, ast.GlobalDecl, ast.ImportStmt,
        ast.InterfaceDecl, ast.ModuleStmt, ast.StructDecl, ast.TypeDecl, []ast.Attribute {
            return FlowSignal{
                kind: .normal
            }
        }
        ast.LabelStmt {
            if stmt.stmt is ast.EmptyStmt {
                return FlowSignal{
                    kind: .normal
                }
            }
            return e.exec_stmt(stmt.stmt)
        }
        else {
            return error('v2.eval: unsupported statement `${stmt.type_name()}`')
        }
    }

    return FlowSignal{
        kind: .normal
    }
}

fn (mut e Eval) exec_expr_stmt(expr ast.Expr) !FlowSignal {
    match expr {
        ast.ComptimeExpr {
            if expr.expr is ast.IfExpr {
                return e.exec_if_stmt(expr.expr)
            }
            _ = e.eval_expr(expr.expr)!
        }
        ast.IfExpr {
            return e.exec_if_stmt(expr)
        }
        ast.InfixExpr {
            if expr.op == .left_shift {
                e.exec_array_append(expr)!
            } else {
                _ = e.eval_expr(expr)!
            }
        }
        ast.PostfixExpr {
            _ = e.eval_postfix_expr(expr)!
        }
        ast.UnsafeExpr {
            return e.exec_block(expr.stmts)
        }
        else {
            _ = e.eval_expr(expr)!
        }
    }

    return FlowSignal{
        kind: .normal
    }
}

fn (mut e Eval) exec_assign_stmt(stmt ast.AssignStmt) !FlowSignal {
    mut values := []Value{}
    for rhs in stmt.rhs {
        values << e.eval_expr(rhs)!
    }
    if stmt.lhs.len > 1 && values.len == 1 && values[0] is TupleValue {
        tuple_value := values[0] as TupleValue
        values = tuple_value.values.clone()
    }
    if stmt.lhs.len != values.len {
        return error('v2.eval: assignment arity mismatch')
    }
    for i, lhs in stmt.lhs {
        match stmt.op {
            .decl_assign {
                e.assign_target(lhs, values[i], true)!
            }
            .assign {
                e.assign_target(lhs, values[i], false)!
            }
            .plus_assign, .minus_assign, .mul_assign, .div_assign, .mod_assign, .and_assign,
            .or_assign, .xor_assign, .left_shift_assign, .right_shift_assign,
            .right_shift_unsigned_assign {
                current := e.eval_expr(lhs)!
                op := assign_to_infix_token(stmt.op)
                updated := e.apply_infix(op, current, values[i])!
                e.assign_target(lhs, updated, false)!
            }
            else {
                return error('v2.eval: unsupported assignment operator `${stmt.op}`')
            }
        }
    }
    return FlowSignal{
        kind: .normal
    }
}

fn assign_to_infix_token(op token.Token) token.Token {
    return match op {
        .plus_assign { .plus }
        .minus_assign { .minus }
        .mul_assign { .mul }
        .div_assign { .div }
        .mod_assign { .mod }
        .and_assign { .amp }
        .or_assign { .pipe }
        .xor_assign { .xor }
        .left_shift_assign { .left_shift }
        .right_shift_assign { .right_shift }
        .right_shift_unsigned_assign { .right_shift_unsigned }
        else { .unknown }
    }
}

fn (mut e Eval) assign_target(lhs ast.Expr, value Value, declare bool) ! {
    if name := assignable_ident_name(lhs) {
        if name == '_' {
            return
        }
        if declare {
            e.declare_var(name, value)
        } else {
            e.update_target(lhs, value)!
        }
        return
    }
    if declare {
        return error('v2.eval: unsupported declaration target `${lhs.type_name()}`')
    }
    return e.update_target(lhs, value)
}

fn can_update_target(expr ast.Expr) bool {
    if assignable_ident_name(expr) != none || expr is ast.IndexExpr || expr is ast.SelectorExpr {
        return true
    }
    match expr {
        ast.CastExpr, ast.ModifierExpr, ast.ParenExpr {
            return can_update_target(expr.expr)
        }
        else {}
    }

    if expr is ast.PrefixExpr && expr.op in [.mul, .amp] {
        return can_update_target(expr.expr)
    }
    return false
}

fn (mut e Eval) update_target(expr ast.Expr, value Value) ! {
    if name := assignable_ident_name(expr) {
        var_result := e.lookup_var(name)
        if var_result.found {
            e.set_var(name, value)!
            return
        }
        if e.set_runtime_const(e.current_module_name(), name, value) {
            return
        }
        return e.unknown_variable_error(name)
    }
    if expr is ast.IndexExpr {
        return e.update_index_target(expr, value)
    }
    if expr is ast.SelectorExpr {
        return e.update_selector_target(expr, value)
    }
    match expr {
        ast.CastExpr, ast.ModifierExpr, ast.ParenExpr {
            return e.update_target(expr.expr, value)
        }
        else {}
    }

    if expr is ast.PrefixExpr && expr.op in [.mul, .amp] {
        return e.update_target(expr.expr, value)
    }
    return error('v2.eval: unsupported assignment target `${expr.type_name()}`')
}

fn assignable_ident_name(expr ast.Expr) ?string {
    match expr {
        ast.Ident {
            return expr.name
        }
        ast.ModifierExpr {
            if expr.expr is ast.Ident {
                return expr.expr.name
            }
        }
        else {}
    }

    return none
}

fn (mut e Eval) update_index_target(expr ast.IndexExpr, value Value) ! {
    container := e.eval_expr(expr.lhs)!
    index_value := e.eval_expr(expr.expr)!
    match container {
        ArrayValue {
            index := int(e.value_as_int(index_value)!)
            if index < 0 || index >= container.values.len {
                return error('v2.eval: array index out of bounds')
            }
            mut updated := ArrayValue{
                ...container
                values: container.values.clone()
            }
            assigned_value := e.adapt_value_to_type_name(value, updated.elem_type_name)
            updated.values[index] = assigned_value
            e.update_target(expr.lhs, updated)!
            return
        }
        MapValue {
            expected_type_name := if container.default_value is VoidValue {
                ''
            } else {
                e.runtime_type_name(container.default_value)
            }
            assigned_value := e.adapt_value_to_type_name(value, expected_type_name)
            e.update_target(expr.lhs, e.map_set_value(container, index_value, assigned_value))!
            return
        }
        else {
            return error('v2.eval: indexed assignment expects an array or map')
        }
    }
}

fn (mut e Eval) update_selector_target(expr ast.SelectorExpr, value Value) ! {
    container := e.eval_expr(expr.lhs)!
    match container {
        ArrayValue {
            if expr.rhs.name == 'flags' {
                return
            }
        }
        StructValue {
            mut updated := container
            mut assigned_value := value
            if field_type := e.lookup_struct_field_type(container.type_name, expr.rhs.name) {
                assigned_value = e.adapt_value_to_type(value, field_type)
            }
            updated.fields[expr.rhs.name] = assigned_value
            e.update_target(expr.lhs, updated)!
            return
        }
        else {
            return error('v2.eval: selector assignment expects a struct, got `${e.runtime_type_name(container)}` in `${e.current_function_label()}`')
        }
    }
}

fn (mut e Eval) exec_array_append(expr ast.InfixExpr) ! {
    container := e.eval_expr(expr.lhs)!
    value := e.eval_expr(expr.rhs)!
    match container {
        ArrayValue {
            mut updated := container
            if value is ArrayValue && e.should_append_many(container, value) {
                if updated.elem_type_name == '' {
                    updated.values << value.values
                } else {
                    for item in value.values {
                        updated.values << e.adapt_value_to_type_name(item, updated.elem_type_name)
                    }
                }
            } else {
                updated.values << e.adapt_value_to_type_name(value, updated.elem_type_name)
            }
            if updated.elem_type_name == '' {
                updated.elem_type_name = e.infer_array_elem_type(updated.values)
            }
            e.update_target(expr.lhs, updated)!
            return
        }
        else {
            return error('v2.eval: `<<` is only supported for arrays')
        }
    }
}

fn (mut e Eval) exec_for_stmt(stmt ast.ForStmt) !FlowSignal {
    e.open_scope()
    defer {
        e.close_scope() or {}
    }
    if stmt.init is ast.ForInStmt {
        return e.exec_for_in(stmt.init, stmt.stmts)
    }
    if stmt.init !is ast.EmptyStmt {
        init_signal := e.exec_stmt(stmt.init)!
        if init_signal.kind != .normal {
            return init_signal
        }
    }
    for {
        if stmt.cond !is ast.EmptyExpr {
            if !e.value_as_bool(e.eval_expr(stmt.cond)!)! {
                break
            }
        }
        body_signal := e.exec_block(stmt.stmts)!
        if body_signal.kind == .return_ {
            return body_signal
        }
        if body_signal.kind == .break_ {
            break
        }
        if stmt.post !is ast.EmptyStmt {
            post_signal := e.exec_stmt(stmt.post)!
            if post_signal.kind == .return_ {
                return post_signal
            }
            if post_signal.kind == .break_ {
                break
            }
        }
    }
    return FlowSignal{
        kind: .normal
    }
}

fn (mut e Eval) exec_for_in(for_in ast.ForInStmt, body []ast.Stmt) !FlowSignal {
    mut key_name := assignable_ident_name(for_in.key) or { '' }
    mut value_name := assignable_ident_name(for_in.value) or { '' }
    if value_name == '' {
        value_name = key_name
        key_name = ''
    }
    iterable := e.eval_expr(for_in.expr)!
    match iterable {
        RangeValue {
            mut i := iterable.start
            limit := iterable.end
            for {
                if iterable.inclusive {
                    if i > limit {
                        break
                    }
                } else if i >= limit {
                    break
                }
                e.open_scope()
                if value_name != '' && value_name != '_' {
                    e.declare_var(value_name, i)
                }
                body_signal := e.exec_stmts(body)!
                e.close_scope()!
                if body_signal.kind == .return_ {
                    return body_signal
                }
                if body_signal.kind == .break_ {
                    break
                }
                i++
            }
        }
        ArrayValue {
            for idx, item in iterable.values {
                e.open_scope()
                if key_name != '' && key_name != '_' {
                    e.declare_var(key_name, i64(idx))
                }
                if value_name != '' && value_name != '_' {
                    e.declare_var(value_name, item)
                }
                body_signal := e.exec_stmts(body)!
                e.close_scope()!
                if body_signal.kind == .return_ {
                    return body_signal
                }
                if body_signal.kind == .break_ {
                    break
                }
            }
        }
        MapValue {
            for entry in iterable.entries {
                e.open_scope()
                if key_name != '' && key_name != '_' {
                    e.declare_var(key_name, entry.key)
                }
                if value_name != '' && value_name != '_' {
                    e.declare_var(value_name, entry.value)
                }
                body_signal := e.exec_stmts(body)!
                e.close_scope()!
                if body_signal.kind == .return_ {
                    return body_signal
                }
                if body_signal.kind == .break_ {
                    break
                }
            }
        }
        string {
            for idx, ch in iterable.runes() {
                e.open_scope()
                if key_name != '' && key_name != '_' {
                    e.declare_var(key_name, i64(idx))
                }
                if value_name != '' && value_name != '_' {
                    e.declare_var(value_name, ch.str())
                }
                body_signal := e.exec_stmts(body)!
                e.close_scope()!
                if body_signal.kind == .return_ {
                    return body_signal
                }
                if body_signal.kind == .break_ {
                    break
                }
            }
        }
        else {
            return error('v2.eval: unsupported for-in iterable `${e.runtime_type_name(iterable)}`')
        }
    }

    return FlowSignal{
        kind: .normal
    }
}

fn (mut e Eval) exec_if_stmt(expr ast.IfExpr) !FlowSignal {
    should_run := if expr.cond is ast.EmptyExpr {
        true
    } else {
        e.value_as_bool(e.eval_expr(expr.cond)!)!
    }
    if should_run {
        return e.exec_block(expr.stmts)
    }
    if expr.else_expr is ast.IfExpr {
        return e.exec_if_stmt(expr.else_expr)
    }
    if expr.else_expr is ast.EmptyExpr {
        return FlowSignal{
            kind: .normal
        }
    }
    _ = e.eval_expr(expr.else_expr)!
    return FlowSignal{
        kind: .normal
    }
}

fn (mut e Eval) eval_expr(expr ast.Expr) !Value {
    match expr {
        ast.ArrayInitExpr {
            mut elem_type_name := if expr.typ is ast.EmptyExpr {
                ''
            } else {
                e.array_elem_type_name(expr.typ)
            }
            if expr.len !is ast.EmptyExpr && expr.exprs.len == 0 {
                size := int(e.value_as_int(e.eval_expr(expr.len)!)!)
                init_value := if expr.init is ast.EmptyExpr {
                    void_value()
                } else {
                    e.eval_expr(expr.init)!
                }
                mut values := []Value{len: size, init: init_value}
                if elem_type_name == '' {
                    elem_type_name = e.infer_array_elem_type(values)
                }
                return ArrayValue{
                    elem_type_name: elem_type_name
                    values:         values
                }
            }
            mut values := []Value{cap: expr.exprs.len}
            // Spread syntax `[...base, e1, e2]` — prepend the base array's
            // values before any explicit elements. Deep-clone each item so
            // the new array does not alias the base's nested storage (mirrors
            // the runtime `array__clone_to_depth` semantics used by lowered
            // codegen paths).
            if expr.update_expr !is ast.EmptyExpr {
                base_value := e.eval_expr(expr.update_expr)!
                if base_value is ArrayValue {
                    cloned_base := e.clone_array_to_depth(base_value, 100)
                    for v in cloned_base.values {
                        values << v
                    }
                    if elem_type_name == '' {
                        elem_type_name = base_value.elem_type_name
                    }
                }
            }
            for item in expr.exprs {
                values << e.eval_expr(item)!
            }
            if elem_type_name == '' {
                elem_type_name = e.infer_array_elem_type(values)
            }
            return ArrayValue{
                elem_type_name: elem_type_name
                values:         values
            }
        }
        ast.InitExpr {
            mut fields := map[string]Value{}
            mut data_fields := map[string]Value{}
            type_name := expr.typ.name()
            for field in expr.fields {
                mut value := e.eval_expr(field.value)!
                if field.name != '' && !field.name.starts_with('_data.') {
                    if field_type := e.lookup_struct_field_type(type_name, field.name) {
                        value = e.adapt_value_to_type(value, field_type)
                    }
                }
                if field.name.starts_with('_data.') {
                    data_fields[field.name.all_after('_data.')] = value
                    continue
                }
                fields[field.name] = value
            }
            if data_fields.len > 0 {
                mut data_struct := StructValue{
                    type_name: type_name + '._data'
                    fields:    map[string]Value{}
                }
                if existing_data := fields['_data'] {
                    if existing_data is StructValue {
                        data_struct = existing_data
                    }
                }
                mut merged_data_fields := data_struct.fields.clone()
                for name, value in data_fields {
                    merged_data_fields[name] = value
                }
                fields['_data'] = StructValue{
                    type_name: data_struct.type_name
                    fields:    merged_data_fields
                }
            }
            return StructValue{
                type_name: type_name
                fields:    fields
            }
        }
        ast.AsCastExpr {
            return e.eval_as_cast_expr(expr)
        }
        ast.BasicLiteral {
            return e.eval_basic_literal(expr)
        }
        ast.CallExpr {
            return e.eval_call_expr(expr)
        }
        ast.CallOrCastExpr {
            if e.is_type_expr(expr.lhs) {
                value := e.eval_expr(expr.expr)!
                target_name := expr.lhs.name()
                if e.is_sum_type_name(target_name) {
                    return e.wrap_sumtype_value(target_name, value, expr.expr) or {
                        e.cast_value(value, target_name)!
                    }
                }
                return e.cast_value(value, target_name)
            }
            return e.eval_call_expr(ast.CallExpr{
                lhs:  expr.lhs
                args: [expr.expr]
                pos:  expr.pos
            })
        }
        ast.CastExpr {
            value := e.eval_expr(expr.expr)!
            target_name := expr.typ.name()
            if e.is_sum_type_name(target_name) {
                return e.wrap_sumtype_value(target_name, value, expr.expr) or {
                    e.cast_value(value, target_name)!
                }
            }
            return e.cast_value(value, target_name)
        }
        ast.ComptimeExpr {
            return e.eval_expr(expr.expr)
        }
        ast.GenericArgs {
            if e.is_type_expr(expr) {
                return TypeValue{
                    name: generic_args_name(expr)
                }
            }
            return error('v2.eval: unsupported generic expression `${generic_args_name(expr)}`')
        }
        ast.Ident {
            return e.eval_ident(expr.name)
        }
        ast.IfExpr {
            return e.eval_if_value(expr)
        }
        ast.IndexExpr {
            return e.eval_index_expr(expr)
        }
        ast.InfixExpr {
            return e.eval_infix_expr(expr)
        }
        ast.KeywordOperator {
            return e.eval_keyword_operator(expr)
        }
        ast.MapInitExpr {
            mut entries := []MapEntry{cap: expr.keys.len}
            for i, key_expr in expr.keys {
                key := e.eval_expr(key_expr)!
                val := if i < expr.vals.len {
                    e.eval_expr(expr.vals[i])!
                } else {
                    void_value()
                }
                entries << MapEntry{
                    key:   key
                    value: val
                }
            }
            default_value := if expr.typ is ast.Type && expr.typ is ast.MapType {
                e.zero_value_for_type_expr((expr.typ as ast.MapType).value_type)
            } else if entries.len > 0 {
                e.zero_value_like(entries[0].value)
            } else {
                void_value()
            }
            return MapValue{
                default_value: default_value
                entries:       entries
            }
        }
        ast.ModifierExpr {
            return e.eval_expr(expr.expr)
        }
        ast.ParenExpr {
            return e.eval_expr(expr.expr)
        }
        ast.PostfixExpr {
            return e.eval_postfix_expr(expr)
        }
        ast.PrefixExpr {
            return e.eval_prefix_expr(expr)
        }
        ast.RangeExpr {
            return RangeValue{
                start:     e.value_as_int(e.eval_expr(expr.start)!)!
                end:       e.value_as_int(e.eval_expr(expr.end)!)!
                inclusive: expr.op == .ellipsis
            }
        }
        ast.SelectorExpr {
            return e.eval_selector_expr(expr)
        }
        ast.StringInterLiteral {
            return e.eval_string_inter(expr)
        }
        ast.StringLiteral {
            return decode_string_literal(expr.value)
        }
        ast.Tuple {
            mut values := []Value{cap: expr.exprs.len}
            for item in expr.exprs {
                values << e.eval_expr(item)!
            }
            return TupleValue{
                values: values
            }
        }
        ast.Type {
            match expr {
                ast.NilType, ast.NoneType {
                    return void_value()
                }
                else {}
            }

            return TypeValue{
                name: e.type_node_name(expr)
            }
        }
        ast.UnsafeExpr {
            return e.eval_unsafe_expr(expr)
        }
        ast.EmptyExpr {
            return void_value()
        }
        else {
            return error('v2.eval: unsupported expression `${expr.type_name()}`')
        }
    }
}

fn (mut e Eval) eval_as_cast_expr(expr ast.AsCastExpr) !Value {
    value := e.eval_expr(expr.expr)!
    target_name := e.type_expr_name(expr.typ)
    if value is StructValue {
        if payload := e.unwrap_sumtype_value(value, target_name) {
            return payload
        }
        if e.value_matches_type_name(value, target_name) {
            return value
        }
        return error('v2.eval: `${value.type_name}` is not `${target_name}` in `${e.current_function_label()}` stack `${e.call_stack_trace()}`')
    }
    if e.value_matches_type_name(value, target_name) {
        return e.cast_value(value, target_name)
    }
    return error('v2.eval: `${e.runtime_type_name(value)}` is not `${target_name}` in `${e.current_function_label()}` stack `${e.call_stack_trace()}`')
}

fn (mut e Eval) eval_basic_literal(expr ast.BasicLiteral) !Value {
    if expr.kind == .key_true {
        v := Value(true)
        return v
    } else if expr.kind == .key_false {
        v := Value(false)
        return v
    } else if expr.kind == .number {
        if expr.value.contains('.') || expr.value.contains('e') || expr.value.contains('E') {
            f := strconv.atof64(expr.value)!
            v := Value(f)
            return v
        } else {
            n := strconv.parse_int(expr.value, 0, 64)!
            v := Value(n)
            return v
        }
    } else if expr.kind == .char {
        if expr.value.len == 0 {
            v := Value(i64(0))
            return v
        } else {
            decoded := decode_string_literal(expr.value)
            if decoded.len == 0 {
                v := Value(i64(0))
                return v
            }
            v := Value(i64(decoded.runes()[0]))
            return v
        }
    } else {
        return error('v2.eval: unsupported literal `${expr.kind}`')
    }
}

fn (mut e Eval) eval_ident(name string) !Value {
    value_result := e.lookup_var(name)
    if value_result.found {
        return value_result.value
    }
    module_name := e.resolve_module_name(name)
    if module_name != '' {
        return ModuleValue{
            name: module_name
        }
    }
    if name == 'nil' || name == 'none' {
        return void_value()
    }
    if e.is_builtin_type_name(name) {
        return TypeValue{
            name: name
        }
    }
    cur_module := e.current_module_name()
    if e.has_type_name(cur_module, name) {
        return TypeValue{
            name: '${cur_module}.${name}'
        }
    }
    if type_value := e.resolve_mangled_type_value(name) {
        return type_value
    }
    const_result := e.lookup_const(cur_module, name)
    if const_result.found {
        return const_result.value
    }
    builtin_const := e.lookup_const('builtin', name)
    if builtin_const.found {
        return builtin_const.value
    }
    if mangled_const := e.resolve_mangled_const(name) {
        return mangled_const
    }
    return error('v2.eval: unknown identifier `${name}` in `${e.current_function_label()}` stack `${e.call_stack_trace()}`')
}

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

fn (e &Eval) has_type_name(module_name string, type_name string) bool {
    if module_name !in e.type_names {
        return false
    }
    return type_name in e.type_names[module_name]
}

fn (mut e Eval) resolve_mangled_const(name string) ?Value {
    for module_name in e.consts.keys() {
        prefix := e.mangled_module_name(module_name) + '__'
        if !name.starts_with(prefix) {
            continue
        }
        key := name[prefix.len..].all_after_last('__')
        const_result := e.lookup_const(module_name, key)
        if const_result.found {
            return const_result.value
        }
    }
    if name.contains('__') {
        type_name := name.all_before_last('__')
        field_name := name.all_after_last('__')
        for module_name, module_types in e.type_names {
            if type_name !in module_types {
                continue
            }
            const_result := e.lookup_const(module_name, field_name)
            if const_result.found {
                return const_result.value
            }
        }
    }
    return none
}

fn (e &Eval) resolve_mangled_type_value(name string) ?TypeValue {
    for module_name, module_types in e.type_names {
        prefix := e.mangled_module_name(module_name) + '__'
        if !name.starts_with(prefix) {
            continue
        }
        type_name := name[prefix.len..]
        if type_name in module_types {
            return TypeValue{
                name: '${module_name}.${type_name}'
            }
        }
    }
    return none
}

fn (e &Eval) mangled_module_name(name string) string {
    if name == '' {
        return ''
    }
    return name.replace('.', '__')
}

fn (mut e Eval) lookup_const(module_name string, name string) MaybeValue {
    if module_name !in e.consts {
        return MaybeValue{}
    }
    mut entry := e.consts[module_name][name] or { return MaybeValue{} }
    if entry.cached {
        return MaybeValue{
            found: true
            value: entry.value
        }
    }
    if entry.evaluating {
        return MaybeValue{}
    }
    entry.evaluating = true
    e.consts[module_name][name] = entry
    e.call_stack << CallFrame{
        module_name: module_name
        file_name:   entry.file_name
        fn_name:     'const ${name}'
    }
    value := e.eval_expr(entry.expr) or {
        entry.evaluating = false
        e.consts[module_name][name] = entry
        e.call_stack.pop()
        return MaybeValue{}
    }
    e.call_stack.pop()
    entry.cached = true
    entry.evaluating = false
    entry.value = value
    e.consts[module_name][name] = entry
    return MaybeValue{
        found: true
        value: value
    }
}

fn (mut e Eval) set_runtime_const(module_name string, name string, value Value) bool {
    if module_name !in e.consts {
        return false
    }
    mut entry := e.consts[module_name][name] or { return false }
    entry.cached = true
    entry.evaluating = false
    entry.value = value
    e.consts[module_name][name] = entry
    return true
}

fn (mut e Eval) eval_call_expr(expr ast.CallExpr) !Value {
    if expr.lhs is ast.SelectorExpr {
        selector := expr.lhs as ast.SelectorExpr
        if builder_result := e.maybe_call_builder_wrapper(selector.rhs.name, expr.args) {
            return builder_result
        }
        if selector.lhs is ast.SelectorExpr {
            inner := selector.lhs as ast.SelectorExpr
            if inner.rhs.name == 'flags' {
                _ = e.eval_expr(inner.lhs)!
                for arg in expr.args {
                    _ = e.eval_expr(arg)!
                }
                return match selector.rhs.name {
                    'set', 'clear' { void_value() }
                    'has' { Value(false) }
                    else { return error('v2.eval: unsupported array flags method `${selector.rhs.name}`') }
                }
            }
        }
        if selector.lhs is ast.Ident {
            module_name := e.resolve_module_name(selector.lhs.name)
            if module_name != '' {
                mut args := []Value{cap: expr.args.len}
                for arg in expr.args {
                    args << e.eval_expr(arg)!
                }
                result := e.call_function(module_name, selector.rhs.name, args)!
                e.writeback_mut_args(expr.args, result)!
                return call_result_value(result)
            }
        }
        receiver := e.eval_expr(selector.lhs)!
        mut args := []Value{cap: expr.args.len}
        for arg in expr.args {
            args << e.eval_expr(arg)!
        }
        if target := e.resolve_method_target(receiver, selector.rhs.name) {
            mut method_args := []Value{cap: args.len + 1}
            method_args << receiver
            method_args << args
            result := e.call_function(target.module_name, target.fn_name, method_args)!
            e.writeback_method_mut_args(selector.lhs, expr.args, result)!
            return call_result_value(result)
        }
        return e.call_value_method(receiver, selector.rhs.name, args)
    }
    if expr.lhs is ast.Ident {
        if builder_result := e.maybe_call_builder_wrapper(expr.lhs.name, expr.args) {
            return builder_result
        }
        mut args := []Value{cap: expr.args.len}
        for arg in expr.args {
            args << e.eval_expr(arg)!
        }
        if target := e.resolve_mangled_function_target(expr.lhs.name) {
            result := e.call_function(target.module_name, target.fn_name, args)!
            e.writeback_mut_args(expr.args, result)!
            return call_result_value(result)
        }
        result := e.call_function(e.current_module_name(), expr.lhs.name, args) or {
            if result := e.call_function('builtin', expr.lhs.name, args) {
                e.writeback_mut_args(expr.args, result)!
                return call_result_value(result)
            }
            return error(err.msg())
        }
        e.writeback_mut_args(expr.args, result)!
        return call_result_value(result)
    }
    return error('v2.eval: unsupported call target `${expr.lhs.type_name()}`')
}

fn (mut e Eval) writeback_method_mut_args(receiver_expr ast.Expr, arg_exprs []ast.Expr, result CallResult) ! {
    for idx, value in result.mut_args {
        if idx == 0 {
            if can_update_target(receiver_expr) {
                e.update_target(receiver_expr, value)!
            }
            continue
        }
        arg_idx := idx - 1
        if arg_idx >= 0 && arg_idx < arg_exprs.len && can_update_target(arg_exprs[arg_idx]) {
            e.update_target(arg_exprs[arg_idx], value)!
        }
    }
}

fn (mut e Eval) maybe_call_builder_wrapper(name string, args []ast.Expr) ?Value {
    if !name.contains('Builder__') || args.len == 0 {
        return none
    }
    method_name := name.all_after('Builder__')
    target_expr := builder_target_expr(args[0]) or { return none }
    target_value := e.eval_expr(target_expr) or { return none }
    if target_value !is ArrayValue {
        return none
    }
    mut receiver := target_value as ArrayValue
    match method_name {
        'cut_last' {
            if args.len < 2 {
                return none
            }
            count_value := e.eval_expr(args[1]) or { return none }
            n := int(e.value_as_int(count_value) or { return none })
            mut items := receiver.values.clone()
            if n <= 0 || n > items.len {
                return ''
            }
            cut := items[items.len - n..].clone()
            items = items[..items.len - n].clone()
            e.update_target(target_expr, ArrayValue{
                values: items
            }) or { return none }
            return e.builder_array_to_string(ArrayValue{
                values: cut
            })
        }
        'go_back' {
            if args.len < 2 {
                return none
            }
            count_value := e.eval_expr(args[1]) or { return none }
            n := int(e.value_as_int(count_value) or { return none })
            if n <= 0 {
                return void_value()
            }
            keep_len := if n > receiver.values.len { 0 } else { receiver.values.len - n }
            e.update_target(target_expr, ArrayValue{
                values: receiver.values[..keep_len].clone()
            }) or { return none }
            return void_value()
        }
        'go_back_to' {
            if args.len < 2 {
                return none
            }
            pos_value := e.eval_expr(args[1]) or { return none }
            pos := int(e.value_as_int(pos_value) or { return none })
            keep_len := if pos < 0 {
                0
            } else if pos > receiver.values.len {
                receiver.values.len
            } else {
                pos
            }
            e.update_target(target_expr, ArrayValue{
                values: receiver.values[..keep_len].clone()
            }) or { return none }
            return void_value()
        }
        'last_n' {
            if args.len < 2 {
                return none
            }
            count_value := e.eval_expr(args[1]) or { return none }
            n := int(e.value_as_int(count_value) or { return none })
            return e.builder_tail_string(receiver, n)
        }
        'after' {
            if args.len < 2 {
                return none
            }
            start_value := e.eval_expr(args[1]) or { return none }
            start := int(e.value_as_int(start_value) or { return none })
            return e.builder_slice_string(receiver, start, receiver.values.len - start)
        }
        'spart' {
            if args.len < 3 {
                return none
            }
            start_value := e.eval_expr(args[1]) or { return none }
            len_value := e.eval_expr(args[2]) or { return none }
            start := int(e.value_as_int(start_value) or { return none })
            n := int(e.value_as_int(len_value) or { return none })
            return e.builder_slice_string(receiver, start, n)
        }
        'str' {
            result := e.builder_array_to_string(receiver)
            e.update_target(target_expr, ArrayValue{
                values: []Value{}
            }) or { return none }
            return result
        }
        'write_ptr' {
            return void_value()
        }
        'write_byte', 'write_rune', 'write_repeated_rune', 'write_string', 'write_string2',
        'write_u8', 'writeln', 'writeln2' {
            mut items := receiver.values.clone()
            match method_name {
                'write_string' {
                    if args.len < 2 {
                        return none
                    }
                    value := e.eval_expr(args[1]) or { return none }
                    e.append_builder_string(mut items, e.value_string(value))
                }
                'write_string2' {
                    if args.len < 3 {
                        return none
                    }
                    first_value := e.eval_expr(args[1]) or { return none }
                    second_value := e.eval_expr(args[2]) or { return none }
                    e.append_builder_string(mut items, e.value_string(first_value))
                    e.append_builder_string(mut items, e.value_string(second_value))
                }
                'write_rune' {
                    if args.len < 2 {
                        return none
                    }
                    rune_value := e.eval_expr(args[1]) or { return none }
                    e.append_builder_rune(mut items, e.value_as_int(rune_value) or { return none })
                }
                'write_repeated_rune' {
                    if args.len < 3 {
                        return none
                    }
                    rune_value := e.eval_expr(args[1]) or { return none }
                    count_value := e.eval_expr(args[2]) or { return none }
                    r := e.value_as_int(rune_value) or { return none }
                    count := int(e.value_as_int(count_value) or { return none })
                    for _ in 0 .. count {
                        e.append_builder_rune(mut items, r)
                    }
                }
                'write_byte', 'write_u8' {
                    if args.len < 2 {
                        return none
                    }
                    byte_value := e.eval_expr(args[1]) or { return none }
                    items << (e.value_as_int(byte_value) or { return none })
                }
                'writeln' {
                    if args.len < 2 {
                        return none
                    }
                    value := e.eval_expr(args[1]) or { return none }
                    e.append_builder_string(mut items, e.value_string(value))
                    items << i64(`\n`)
                }
                'writeln2' {
                    if args.len < 3 {
                        return none
                    }
                    first_value := e.eval_expr(args[1]) or { return none }
                    second_value := e.eval_expr(args[2]) or { return none }
                    e.append_builder_string(mut items, e.value_string(first_value))
                    items << i64(`\n`)
                    e.append_builder_string(mut items, e.value_string(second_value))
                    items << i64(`\n`)
                }
                else {}
            }

            e.update_target(target_expr, ArrayValue{
                values: items
            }) or { return none }
            return void_value()
        }
        else {
            return none
        }
    }
}

fn builder_target_expr(expr ast.Expr) ?ast.Expr {
    match expr {
        ast.CastExpr {
            return builder_target_expr(expr.expr)
        }
        ast.Ident {
            return expr
        }
        ast.ModifierExpr {
            return builder_target_expr(expr.expr)
        }
        ast.ParenExpr {
            return builder_target_expr(expr.expr)
        }
        ast.SelectorExpr {
            return expr
        }
        ast.PrefixExpr {
            if expr.op == .amp {
                return builder_target_expr(expr.expr)
            }
        }
        else {}
    }

    return none
}

fn receiver_method_type_candidates(receiver Value) []string {
    return match receiver {
        StructValue {
            struct_field_lookup_candidates(receiver.type_name)
        }
        TypeValue {
            struct_field_lookup_candidates(receiver.name)
        }
        else {
            []string{}
        }
    }
}

fn (e &Eval) resolve_method_target(receiver Value, method_name string) ?MaybeFunctionTarget {
    candidates := receiver_method_type_candidates(receiver)
    if candidates.len == 0 {
        return none
    }
    for module_name, functions in e.functions {
        for candidate in candidates {
            key := '${candidate}__${method_name}'
            if key in functions {
                return MaybeFunctionTarget{
                    found:       true
                    module_name: module_name
                    fn_name:     key
                }
            }
        }
    }
    return none
}

fn (e &Eval) append_builder_string(mut items []Value, s string) {
    for b in s.bytes() {
        items << i64(b)
    }
}

fn (e &Eval) append_builder_rune(mut items []Value, r i64) {
    e.append_builder_string(mut items, rune(r).str())
}

fn (e &Eval) builder_array_to_string(receiver ArrayValue) string {
    mut bytes := []u8{cap: receiver.values.len}
    for item in receiver.values {
        bytes << u8(e.value_as_int(item) or { 0 })
    }
    return bytes.bytestr()
}

fn (e &Eval) builder_slice_string(receiver ArrayValue, start_pos int, n int) string {
    if start_pos < 0 || n <= 0 || start_pos >= receiver.values.len {
        return ''
    }
    end := if start_pos + n > receiver.values.len {
        receiver.values.len
    } else {
        start_pos + n
    }
    return e.builder_array_to_string(ArrayValue{
        values: receiver.values[start_pos..end].clone()
    })
}

fn (e &Eval) builder_tail_string(receiver ArrayValue, n int) string {
    if n <= 0 || n > receiver.values.len {
        return ''
    }
    return e.builder_array_to_string(ArrayValue{
        values: receiver.values[receiver.values.len - n..].clone()
    })
}

fn (mut e Eval) eval_if_value(expr ast.IfExpr) !Value {
    should_run := if expr.cond is ast.EmptyExpr {
        true
    } else {