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 {
        e.value_as_bool(e.eval_expr(expr.cond)!)!
    }
    if should_run {
        return e.eval_block_value(expr.stmts)
    }
    if expr.else_expr is ast.IfExpr {
        return e.eval_if_value(expr.else_expr)
    }
    if expr.else_expr is ast.EmptyExpr {
        return void_value()
    }
    return e.eval_expr(expr.else_expr)
}

fn (e &Eval) resolve_mangled_function_target(name string) ?MaybeFunctionTarget {
    for module_name, functions in e.functions {
        prefix := e.mangled_module_name(module_name) + '__'
        if !name.starts_with(prefix) {
            continue
        }
        fn_name := name[prefix.len..]
        if fn_name in functions {
            return MaybeFunctionTarget{
                found:       true
                module_name: module_name
                fn_name:     fn_name
            }
        }
    }
    return none
}

fn (mut e Eval) eval_block_value(stmts []ast.Stmt) !Value {
    e.open_scope()
    defer {
        e.close_scope() or {}
    }
    if stmts.len == 0 {
        return void_value()
    }
    for i, stmt in stmts {
        is_last := i == stmts.len - 1
        if is_last && stmt is ast.ExprStmt {
            if stmt.expr is ast.IfExpr {
                return e.eval_if_value(stmt.expr)
            }
            return e.eval_expr(stmt.expr)
        }
        signal := e.exec_stmt(stmt)!
        if signal.kind != .normal {
            return error('v2.eval: control flow inside expression block is not supported yet')
        }
    }
    return void_value()
}

fn (mut e Eval) eval_index_expr(expr ast.IndexExpr) !Value {
    container := e.eval_expr(expr.lhs)!
    if expr.expr is ast.RangeExpr {
        range_value := e.eval_expr(expr.expr)! as RangeValue
        start := int(range_value.start)
        end := int(range_value.end) + if range_value.inclusive { 1 } else { 0 }
        match container {
            ArrayValue {
                return ArrayValue{
                    values: container.values[start..end]
                }
            }
            string {
                s := container[start..end]
                return s
            }
            else {
                return error('v2.eval: slicing is only supported for arrays and strings')
            }
        }
    }
    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')
            }
            return container.values[index]
        }
        MapValue {
            return e.map_get_or_default(container, index_value)
        }
        string {
            index := int(e.value_as_int(index_value)!)
            if index < 0 || index >= container.len {
                return error('v2.eval: string index out of bounds')
            }
            return i64(container[index])
        }
        else {
            return error('v2.eval: unsupported index target `${e.runtime_type_name(container)}`')
        }
    }
}

fn (mut e Eval) eval_infix_expr(expr ast.InfixExpr) !Value {
    if expr.op == .and {
        left := e.value_as_bool(e.eval_expr(expr.lhs)!)!
        if !left {
            return Value(false)
        }
        return e.value_as_bool(e.eval_expr(expr.rhs)!)!
    }
    if expr.op == .logical_or {
        left := e.value_as_bool(e.eval_expr(expr.lhs)!)!
        if left {
            return Value(true)
        }
        return e.value_as_bool(e.eval_expr(expr.rhs)!)!
    }
    left := e.eval_expr(expr.lhs)!
    right := e.eval_expr(expr.rhs)!
    return e.apply_infix(expr.op, left, right)
}

fn (mut e Eval) apply_infix(op token.Token, left Value, right Value) !Value {
    match op {
        .plus {
            if left is string || right is string {
                return e.value_string(left) + e.value_string(right)
            }
            if left is f64 || right is f64 {
                return e.value_as_f64(left)! + e.value_as_f64(right)!
            }
            return e.value_as_int(left)! + e.value_as_int(right)!
        }
        .minus {
            if left is f64 || right is f64 {
                return e.value_as_f64(left)! - e.value_as_f64(right)!
            }
            return e.value_as_int(left)! - e.value_as_int(right)!
        }
        .mul {
            if left is f64 || right is f64 {
                return e.value_as_f64(left)! * e.value_as_f64(right)!
            }
            return e.value_as_int(left)! * e.value_as_int(right)!
        }
        .div {
            if left is f64 || right is f64 {
                return e.value_as_f64(left)! / e.value_as_f64(right)!
            }
            return e.value_as_int(left)! / e.value_as_int(right)!
        }
        .mod {
            return e.value_as_int(left)! % e.value_as_int(right)!
        }
        .eq {
            return e.value_eq(left, right)
        }
        .ne {
            return !e.value_eq(left, right)
        }
        .lt {
            return e.compare_values(left, right) < 0
        }
        .le {
            return e.compare_values(left, right) <= 0
        }
        .gt {
            return e.compare_values(left, right) > 0
        }
        .ge {
            return e.compare_values(left, right) >= 0
        }
        .key_is {
            return e.value_is_type(left, right)
        }
        .not_is {
            return !e.value_is_type(left, right)
        }
        .amp {
            return e.value_as_int(left)! & e.value_as_int(right)!
        }
        .pipe {
            return e.value_as_int(left)! | e.value_as_int(right)!
        }
        .xor {
            return e.value_as_int(left)! ^ e.value_as_int(right)!
        }
        .left_shift {
            return i64(u64(e.value_as_int(left)!) << u64(e.value_as_int(right)!))
        }
        .right_shift {
            return e.value_as_int(left)! >> e.value_as_int(right)!
        }
        .right_shift_unsigned {
            return i64(u64(e.value_as_int(left)!) >> u64(e.value_as_int(right)!))
        }
        .key_in {
            match right {
                ArrayValue {
                    for item in right.values {
                        if e.value_eq(left, item) {
                            return true
                        }
                    }
                    return false
                }
                string {
                    return right.contains(e.value_string(left))
                }
                MapValue {
                    return e.map_contains_key(right, left)
                }
                else {
                    return error('v2.eval: unsupported `in` rhs `${e.runtime_type_name(right)}`')
                }
            }
        }
        .not_in {
            in_result := e.apply_infix(.key_in, left, right)!
            return !e.value_as_bool(in_result)!
        }
        else {
            return error('v2.eval: unsupported infix operator `${op}`')
        }
    }
}

fn (e &Eval) value_is_type(value Value, rhs Value) bool {
    target_name := match rhs {
        TypeValue { rhs.name }
        string { rhs }
        else { e.runtime_type_name(rhs) }
    }

    if value is StructValue && e.unwrap_sumtype_value(value, target_name) != none {
        return true
    }
    return e.value_matches_type_name(value, target_name)
}

fn (e &Eval) compare_values(left Value, right Value) int {
    if left is string || right is string {
        ls := e.value_string(left)
        rs := e.value_string(right)
        if ls < rs {
            return -1
        }
        if ls > rs {
            return 1
        }
        return 0
    }
    if left is f64 || right is f64 {
        lf := e.value_as_f64(left) or { 0.0 }
        rf := e.value_as_f64(right) or { 0.0 }
        if lf < rf {
            return -1
        }
        if lf > rf {
            return 1
        }
        return 0
    }
    li := e.value_as_int(left) or { 0 }
    ri := e.value_as_int(right) or { 0 }
    if li < ri {
        return -1
    }
    if li > ri {
        return 1
    }
    return 0
}

fn (e &Eval) value_eq(left Value, right Value) bool {
    match left {
        bool {
            return right is bool && left == right
        }
        i64 {
            if right is i64 {
                return left == right
            }
            if right is f64 {
                return f64(left) == value_f64_payload(right)
            }
            return false
        }
        f64 {
            left_f := value_f64_payload(left)
            if right is f64 {
                return left_f == value_f64_payload(right)
            }
            if right is i64 {
                return left_f == f64(right)
            }
            return false
        }
        string {
            return right is string && left == right
        }
        ArrayValue {
            if right !is ArrayValue {
                return false
            }
            right_array := right as ArrayValue
            if left.values.len != right_array.values.len {
                return false
            }
            for i, item in left.values {
                if !e.value_eq(item, right_array.values[i]) {
                    return false
                }
            }
            return true
        }
        MapValue {
            if right !is MapValue {
                return false
            }
            right_map := right as MapValue
            if left.entries.len != right_map.entries.len {
                return false
            }
            for entry in left.entries {
                right_value, found := e.map_lookup(right_map, entry.key)
                if !found || !e.value_eq(entry.value, right_value) {
                    return false
                }
            }
            return true
        }
        StructValue {
            if right !is StructValue {
                return false
            }
            right_struct := right as StructValue
            if left.type_name != right_struct.type_name
                || left.fields.len != right_struct.fields.len {
                return false
            }
            for key, value in left.fields {
                right_value := right_struct.fields[key] or { return false }
                if !e.value_eq(value, right_value) {
                    return false
                }
            }
            return true
        }
        FlagsValue {
            return right is FlagsValue
        }
        ModuleValue {
            return right is ModuleValue && left.name == right.name
        }
        TypeValue {
            return right is TypeValue && left.name == right.name
        }
        VoidValue {
            return right is VoidValue
        }
        TupleValue {
            if right !is TupleValue {
                return false
            }
            right_tuple := right as TupleValue
            if left.values.len != right_tuple.values.len {
                return false
            }
            for i, item in left.values {
                if !e.value_eq(item, right_tuple.values[i]) {
                    return false
                }
            }
            return true
        }
        RangeValue {
            return right is RangeValue && left.start == right.start && left.end == right.end
                && left.inclusive == right.inclusive
        }
    }
}

fn (mut e Eval) eval_keyword_operator(expr ast.KeywordOperator) !Value {
    match expr.op {
        .key_isreftype {
            if expr.exprs.len == 0 {
                return error('v2.eval: isreftype expects one argument')
            }
            if e.is_type_expr(expr.exprs[0]) {
                return e.is_ref_type_name(e.type_expr_name(expr.exprs[0]))
            }
            value := e.eval_expr(expr.exprs[0])!
            return e.is_ref_type_name(e.runtime_type_name(value))
        }
        .key_sizeof {
            if expr.exprs.len == 0 {
                return error('v2.eval: sizeof expects one argument')
            }
            if e.is_type_expr(expr.exprs[0]) {
                return e.sizeof_type_name(e.type_expr_name(expr.exprs[0]))
            }
            value := e.eval_expr(expr.exprs[0])!
            return e.sizeof_type_name(e.runtime_type_name(value))
        }
        .key_typeof {
            if expr.exprs.len == 0 {
                return error('v2.eval: typeof expects one argument')
            }
            value := e.eval_expr(expr.exprs[0])!
            return TypeValue{
                name: e.runtime_type_name(value)
            }
        }
        else {
            return error('v2.eval: unsupported keyword operator `${expr.op}`')
        }
    }
}

fn (mut e Eval) eval_postfix_expr(expr ast.PostfixExpr) !Value {
    if !can_update_target(expr.expr) {
        return error('v2.eval: postfix update expects an assignable target')
    }
    current := e.eval_expr(expr.expr)!
    current_i64 := e.value_as_int(current)!
    updated := if expr.op == .inc { current_i64 + 1 } else { current_i64 - 1 }
    e.update_target(expr.expr, updated)!
    return updated
}

fn (mut e Eval) eval_prefix_expr(expr ast.PrefixExpr) !Value {
    value := e.eval_expr(expr.expr)!
    match expr.op {
        .not {
            return !e.value_as_bool(value)!
        }
        .amp, .mul {
            return value
        }
        .bit_not {
            return ~e.value_as_int(value)!
        }
        .minus {
            if value is f64 {
                f := -value_f64_payload(value)
                return f
            }
            return -e.value_as_int(value)!
        }
        .plus {
            return value
        }
        else {
            return error('v2.eval: unsupported prefix operator `${expr.op}`')
        }
    }
}

fn (mut e Eval) eval_selector_expr(expr ast.SelectorExpr) !Value {
    if expr.lhs is ast.EmptyExpr {
        const_result := e.lookup_const(e.current_module_name(), expr.rhs.name)
        if const_result.found {
            return const_result.value
        }
        return error('v2.eval: enum shorthand `${expr.rhs.name}` is not supported yet')
    }
    left := e.eval_expr(expr.lhs)!
    if expr.rhs.name == '_tag' {
        if tag := e.contextual_sumtype_tag(expr.lhs, left) {
            return i64(tag)
        }
    }
    if expr.rhs.name == '_data' {
        if left !is StructValue || '_data' !in (left as StructValue).fields {
            if _ := e.contextual_sumtype_tag(expr.lhs, left) {
                return left
            }
        }
    }
    match left {
        ModuleValue {
            prop := e.module_property(left.name, expr.rhs.name)
            if prop.found {
                return prop.value
            }
            if e.has_type_name(left.name, expr.rhs.name) {
                return TypeValue{
                    name: '${left.name}.${expr.rhs.name}'
                }
            }
            if expr.rhs.name.contains('__') {
                short_name := expr.rhs.name.all_after_last('__')
                if short_name != '' {
                    if e.has_type_name(left.name, short_name) {
                        return TypeValue{
                            name: '${left.name}.${short_name}'
                        }
                    }
                    const_result := e.lookup_const(left.name, short_name)
                    if const_result.found {
                        return const_result.value
                    }
                }
                module_prefix := e.mangled_module_name(left.name) + '__'
                if expr.rhs.name.starts_with(module_prefix) {
                    normalized_name := expr.rhs.name[module_prefix.len..]
                    if e.has_type_name(left.name, normalized_name) {
                        return TypeValue{
                            name: '${left.name}.${normalized_name}'
                        }
                    }
                }
            }
            const_result := e.lookup_const(left.name, expr.rhs.name)
            if const_result.found {
                return const_result.value
            }
            return error('v2.eval: unknown module selector `${left.name}.${expr.rhs.name}`')
        }
        ArrayValue {
            if expr.rhs.name == 'len' {
                return i64(left.values.len)
            }
            if expr.rhs.name == 'flags' {
                return FlagsValue{}
            }
            if expr.rhs.name == 'str' {
                return e.value_string(left)
            }
        }
        MapValue {
            if expr.rhs.name == 'len' {
                return i64(left.entries.len)
            }
            if expr.rhs.name == 'str' {
                return e.value_string(left)
            }
        }
        StructValue {
            if expr.rhs.name == 'mtx' {
                return StructValue{
                    type_name: 'sync__RwMutex'
                    fields:    map[string]Value{}
                }
            }
            if expr.rhs.name == '_tag' {
                if tag := e.inferred_sumtype_tag(left) {
                    return i64(tag)
                }
            }
            if expr.rhs.name == '_data' && '_data' !in left.fields {
                if _ := e.inferred_sumtype_tag(left) {
                    return left
                }
            }
            if variant_value := e.sumtype_variant_field_value(left, expr.rhs.name) {
                return variant_value
            }
            if expr.rhs.name in left.fields {
                field_value := left.fields[expr.rhs.name] or {
                    return error('v2.eval: unknown struct field `${expr.rhs.name}` on `${left.type_name}` fields `${left.fields.keys()}` in `${e.current_function_label()}` stack `${e.call_stack_trace()}`')
                }
                if left.type_name.ends_with('._data') && expr.rhs.name.starts_with('_')
                    && is_semantically_empty_value(field_value) {
                    if zero_payload := e.zero_value_for_sumtype_data_field(left.type_name,
                        expr.rhs.name)
                    {
                        return zero_payload
                    }
                }
                return field_value
            }
            if zero_payload := e.zero_value_for_sumtype_data_field(left.type_name, expr.rhs.name) {
                return zero_payload
            }
            if embedded_value := e.lookup_embedded_struct_field_value(left, expr.rhs.name, 0) {
                return embedded_value
            }
            if field_type := e.lookup_struct_field_type(left.type_name, expr.rhs.name) {
                return e.zero_value_for_type_expr(field_type)
            }
            return error('v2.eval: unknown struct field `${expr.rhs.name}` on `${left.type_name}` fields `${left.fields.keys()}` in `${e.current_function_label()}` stack `${e.call_stack_trace()}`')
        }
        string {
            if expr.rhs.name == 'len' {
                return i64(left.len)
            }
            if expr.rhs.name == 'str' {
                return left
            }
        }
        i64 {
            if expr.rhs.name == 'str' {
                return e.value_string(left)
            }
            if expr.rhs.name == '_tag' || expr.rhs.name == '_data' {
                return Value(left)
            }
        }
        f64 {
            if expr.rhs.name == 'str' {
                return e.value_string(left)
            }
        }
        bool {
            if expr.rhs.name == 'str' {
                return e.value_string(left)
            }
        }
        TypeValue {
            if expr.rhs.name == '_tag' {
                if tag := e.inferred_sumtype_tag(left) {
                    return i64(tag)
                }
            }
            if expr.rhs.name == '_data' {
                if _ := e.inferred_sumtype_tag(left) {
                    return left
                }
            }
            module_name := e.type_value_module_name(left)
            if module_name != '' {
                const_result := e.lookup_const(module_name, expr.rhs.name)
                if const_result.found {
                    return const_result.value
                }
            }
            if expr.rhs.name == 'name' {
                s := left.name
                v := Value(s)
                return v
            }
        }
        else {}
    }

    return error('v2.eval: unsupported selector `${expr.rhs.name}` on `${e.runtime_type_name(left)}` from `${expr.lhs.type_name()}` `${expr.lhs.name()}` in `${e.current_function_label()}`')
}

fn (e &Eval) type_value_module_name(value TypeValue) string {
    if !value.name.contains('.') {
        return ''
    }
    return value.name.all_before_last('.')
}

fn struct_field_lookup_candidates(type_name string) []string {
    mut candidates := []string{}
    mut trimmed := type_name.trim_left('&').trim_right('*')
    if trimmed == '' {
        return candidates
    }
    add_type_name_alias(mut candidates, trimmed)
    if trimmed.contains('__') {
        add_type_name_alias(mut candidates, trimmed.replace('__', '.'))
        add_type_name_alias(mut candidates, trimmed.all_after_last('__'))
    }
    if trimmed.contains('.') {
        add_type_name_alias(mut candidates, trimmed.all_after_last('.'))
    }
    return candidates
}

fn (e &Eval) qualify_type_name(module_name string, type_name string) string {
    if module_name == '' || type_name == '' {
        return type_name
    }
    if type_name.starts_with('[]') {
        return '[]' + e.qualify_type_name(module_name, type_name[2..])
    }
    if type_name.starts_with('?') || type_name.starts_with('!') {
        return type_name[..1] + e.qualify_type_name(module_name, type_name[1..])
    }
    if type_name.starts_with('&') {
        return '&' + e.qualify_type_name(module_name, type_name[1..])
    }
    if type_name.starts_with('chan ') {
        return 'chan ' + e.qualify_type_name(module_name, type_name[5..])
    }
    if type_name.starts_with('thread ') {
        return 'thread ' + e.qualify_type_name(module_name, type_name[7..])
    }
    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..]
            return 'map[${e.qualify_type_name(module_name, key_name)}]${e.qualify_type_name(module_name,
                value_name)}'
        }
    }
    if (type_name.starts_with('[') && type_name.contains(']'))
        || type_name.contains('.') || type_name.contains('__')
        || e.is_builtin_type_name(type_name) || type_name in ['nil', 'none'] {
        return type_name
    }
    if e.has_type_name(module_name, type_name) {
        return '${module_name}.${type_name}'
    }
    return type_name
}

fn (e &Eval) qualify_type_expr(module_name string, expr ast.Expr) ast.Expr {
    return match expr {
        ast.GenericArgs {
            ast.Expr(ast.GenericArgs{
                lhs:  e.qualify_type_expr(module_name, expr.lhs)
                args: expr.args.map(e.qualify_type_expr(module_name, it))
                pos:  expr.pos
            })
        }
        ast.Ident {
            qualified_name := e.qualify_type_name(module_name, expr.name)
            if qualified_name == expr.name {
                ast.Expr(expr)
            } else {
                parts := qualified_name.split('.')
                if parts.len == 2 {
                    ast.Expr(ast.SelectorExpr{
                        lhs: ast.Expr(ast.Ident{
                            name: parts[0]
                        })
                        rhs: ast.Ident{
                            name: parts[1]
                        }
                    })
                } else {
                    ast.Expr(expr)
                }
            }
        }
        ast.ModifierExpr {
            ast.Expr(ast.ModifierExpr{
                kind: expr.kind
                expr: e.qualify_type_expr(module_name, expr.expr)
            })
        }
        ast.ParenExpr {
            ast.Expr(ast.ParenExpr{
                expr: e.qualify_type_expr(module_name, expr.expr)
            })
        }
        ast.Type {
            match expr {
                ast.ArrayFixedType {
                    ast.Expr(ast.Type(ast.ArrayFixedType{
                        len:       expr.len
                        elem_type: e.qualify_type_expr(module_name, expr.elem_type)
                    }))
                }
                ast.ArrayType {
                    ast.Expr(ast.Type(ast.ArrayType{
                        elem_type: e.qualify_type_expr(module_name, expr.elem_type)
                    }))
                }
                ast.ChannelType {
                    ast.Expr(ast.Type(ast.ChannelType{
                        cap:       expr.cap
                        elem_type: e.qualify_type_expr(module_name, expr.elem_type)
                    }))
                }
                ast.GenericType {
                    ast.Expr(ast.Type(ast.GenericType{
                        name:   e.qualify_type_expr(module_name, expr.name)
                        params: expr.params.map(e.qualify_type_expr(module_name, it))
                    }))
                }
                ast.MapType {
                    ast.Expr(ast.Type(ast.MapType{
                        key_type:   e.qualify_type_expr(module_name, expr.key_type)
                        value_type: e.qualify_type_expr(module_name, expr.value_type)
                    }))
                }
                ast.OptionType {
                    ast.Expr(ast.Type(ast.OptionType{
                        base_type: e.qualify_type_expr(module_name, expr.base_type)
                    }))
                }
                ast.ResultType {
                    ast.Expr(ast.Type(ast.ResultType{
                        base_type: e.qualify_type_expr(module_name, expr.base_type)
                    }))
                }
                ast.ThreadType {
                    ast.Expr(ast.Type(ast.ThreadType{
                        elem_type: e.qualify_type_expr(module_name, expr.elem_type)
                    }))
                }
                ast.TupleType {
                    ast.Expr(ast.Type(ast.TupleType{
                        types: expr.types.map(e.qualify_type_expr(module_name, it))
                    }))
                }
                else {
                    expr
                }
            }
        }
        else {
            expr
        }
    }
}

fn (e &Eval) lookup_struct_embed_types(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_embeds := e.struct_embeds[module_name] {
                if embed_names := module_embeds[short_type_name] {
                    return embed_names.map(e.qualify_type_name(module_name, it))
                }
            }
            continue
        }
        current_module := e.current_module_name()
        if module_embeds := e.struct_embeds[current_module] {
            if embed_names := module_embeds[short_type_name] {
                return embed_names.map(e.qualify_type_name(current_module, it))
            }
        }
        for mod_name, module_embeds in e.struct_embeds {
            if embed_names := module_embeds[short_type_name] {
                return embed_names.map(e.qualify_type_name(mod_name, it))
            }
        }
    }
    return []string{}
}

fn (e &Eval) lookup_struct_field_type(type_name string, field_name string) ?ast.Expr {
    return e.lookup_struct_field_type_with_depth(type_name, field_name, 0)
}

fn (e &Eval) lookup_struct_field_type_with_depth(type_name string, field_name string, depth int) ?ast.Expr {
    if depth > 16 {
        return none
    }
    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] {
                    if field_name in type_fields {
                        return e.qualify_type_expr(module_name, type_fields[field_name] or {
                            return none
                        })
                    }
                }
            }
            for embedded_type in e.lookup_struct_embed_types(candidate) {
                if embedded_field_type := e.lookup_struct_field_type_with_depth(embedded_type,
                    field_name, depth + 1)
                {
                    return embedded_field_type
                }
            }
            continue
        }
        current_module := e.current_module_name()
        if module_fields := e.struct_field_types[current_module] {
            if type_fields := module_fields[short_type_name] {
                if field_name in type_fields {
                    return e.qualify_type_expr(current_module, type_fields[field_name] or {
                        return none
                    })
                }
            }
        }
        for mod_name, module_fields in e.struct_field_types {
            if type_fields := module_fields[short_type_name] {
                if field_name in type_fields {
                    return e.qualify_type_expr(mod_name, type_fields[field_name] or { return none })
                }
            }
        }
        for embedded_type in e.lookup_struct_embed_types(candidate) {
            if embedded_field_type := e.lookup_struct_field_type_with_depth(embedded_type,
                field_name, depth + 1)
            {
                return embedded_field_type
            }
        }
    }
    return none
}

fn (e &Eval) lookup_embedded_struct_field_value(value StructValue, field_name string, depth int) ?Value {
    if depth > 16 {
        return none
    }
    for embedded_type in e.lookup_struct_embed_types(value.type_name) {
        for embedded_alias in struct_field_lookup_candidates(embedded_type) {
            if embedded_value := value.fields[embedded_alias] {
                if embedded_value is StructValue {
                    embedded_struct := embedded_value as StructValue
                    if field_name in embedded_struct.fields {
                        return embedded_struct.fields[field_name] or { return none }
                    }
                    if nested_value := e.lookup_embedded_struct_field_value(embedded_struct,
                        field_name, depth + 1)
                    {
                        return nested_value
                    }
                }
            }
        }
    }
    return none
}

fn (e &Eval) zero_struct_value(type_name string) StructValue {
    if info := e.sum_type_info(type_name) {
        return e.build_sumtype_wrapper(type_name, info, 0, void_value())
    }
    mut fields := map[string]Value{}
    mut module_name := ''
    mut short_type_name := type_name
    if type_name.contains('.') {
        module_name = type_name.all_before_last('.')
        short_type_name = type_name.all_after_last('.')
    }
    if module_name != '' {
        if module_fields := e.struct_field_types[module_name] {
            if type_fields := module_fields[short_type_name] {
                for field_name, field_type in type_fields {
                    fields[field_name] = e.zero_value_for_type_expr(e.qualify_type_expr(module_name,
                        field_type))
                }
            }
        }
    } else if module_fields := e.struct_field_types[e.current_module_name()] {
        if type_fields := module_fields[short_type_name] {
            for field_name, field_type in type_fields {
                fields[field_name] = e.zero_value_for_type_expr(e.qualify_type_expr(e.current_module_name(),
                    field_type))
            }
        }
    }
    return StructValue{
        type_name: type_name
        fields:    fields
    }
}

fn (mut e Eval) eval_string_inter(expr ast.StringInterLiteral) !Value {
    mut out := ''
    for i, part in expr.values {
        mut decoded := decode_string_literal(part)
        if part in ['"', "'"] && (i == 0 || i == expr.values.len - 1) {
            decoded = ''
        }
        out += decoded
        if i < expr.inters.len {
            inter := expr.inters[i]
            out += e.value_string(e.eval_expr(inter.expr)!)
        }
    }
    return out
}

fn decode_string_literal(raw string) string {
    mut s := raw
    if s.len >= 2 && ((s[0] == `"` && s[s.len - 1] == `"`) || (s[0] == `'` && s[s.len - 1] == `'`)) {
        s = s[1..s.len - 1]
    }
    return s.replace('\\n', '\n').replace('\\r', '\r').replace('\\t', '\t').replace('\\0', '\0').replace('\\"',
        '"').replace("\\'", "'").replace('\\`', '`').replace('\\\\', '\\').replace('\\$', '$')
}

fn (mut e Eval) eval_unsafe_expr(expr ast.UnsafeExpr) !Value {
    if expr.stmts.len == 0 {
        return void_value()
    }
    e.open_scope()
    defer {
        e.close_scope() or {}
    }
    for i, stmt in expr.stmts {
        is_last := i == expr.stmts.len - 1
        if is_last && stmt is ast.ExprStmt {
            return e.eval_expr(stmt.expr)
        }
        signal := e.exec_stmt(stmt)!
        if signal.kind != .normal {
            return error('v2.eval: control flow inside unsafe expression is not supported')
        }
    }
    return void_value()
}

fn (mut e Eval) call_value_method(receiver Value, method_name string, args []Value) !Value {
    if method_name == 'str' && args.len == 0 {
        return e.value_string(receiver)
    }
    match receiver {
        string {
            return e.call_string_method(receiver, method_name, args)
        }
        ArrayValue {
            return e.call_array_method(receiver, method_name, args)
        }
        FlagsValue {
            return e.call_flags_method(method_name, args)
        }
        MapValue {
            if method_name == 'str' && args.len == 0 {
                return e.value_string(receiver)
            }
        }
        i64 {
            if args.len == 0 && receiver >= 0 && receiver <= 255 {
                if byte_value := eval_byte_method_value(u8(receiver), method_name) {
                    return byte_value
                }
            }
            if args.len == 0 && method_name != 'str' {
                // Token enum values are stored as ints in eval, so enum helpers need a narrow cast here.
                if token_value := eval_token_method_value(unsafe { token.Token(int(receiver)) },
                    method_name)
                {
                    return token_value
                }
            }
            if method_name == 'str' && args.len == 0 {
                return e.value_string(receiver)
            }
        }
        f64, bool {
            if method_name == 'str' && args.len == 0 {
                return e.value_string(receiver)
            }
        }
        else {}
    }

    return error('v2.eval: unsupported method `${method_name}` on `${e.runtime_type_name(receiver)}`')
}

fn (mut e Eval) call_string_method(receiver string, method_name string, args []Value) !Value {
    match method_name {
        'all_after' {
            return receiver.all_after(e.expect_string_arg(args, 0)!)
        }
        'all_after_last' {
            return receiver.all_after_last(e.expect_string_arg(args, 0)!)
        }
        'all_before' {
            return receiver.all_before(e.expect_string_arg(args, 0)!)
        }
        'all_before_last' {
            return receiver.all_before_last(e.expect_string_arg(args, 0)!)
        }
        'contains' {
            return receiver.contains(e.expect_string_arg(args, 0)!)
        }
        'bytes', 'vbytes' {
            mut values := []Value{cap: receiver.len}
            for b in receiver.bytes() {
                values << i64(b)
            }
            return ArrayValue{
                values: values
            }
        }
        'clone' {
            return receiver.clone()
        }
        'ends_with' {
            return receiver.ends_with(e.expect_string_arg(args, 0)!)
        }
        'ge' {
            return receiver >= e.expect_string_arg(args, 0)!
        }
        'gt' {
            return receiver > e.expect_string_arg(args, 0)!
        }
        'int' {
            return i64(receiver.int())
        }
        'index' {
            idx := receiver.index(e.expect_string_arg(args, 0)!) or { return wrap_option_none() }
            return wrap_option_ok(i64(idx))
        }
        'i64' {
            return receiver.i64()
        }
        'last_index' {
            idx := receiver.last_index(e.expect_string_arg(args, 0)!) or {
                return wrap_option_none()
            }
            return wrap_option_ok(i64(idx))
        }
        'le' {
            return receiver <= e.expect_string_arg(args, 0)!
        }
        'lt' {
            return receiver < e.expect_string_arg(args, 0)!
        }
        'ne' {
            return receiver != e.expect_string_arg(args, 0)!
        }
        'plus' {
            return receiver + e.expect_string_arg(args, 0)!
        }
        'plus_two' {
            return receiver + e.expect_string_arg(args, 0)! + e.expect_string_arg(args, 1)!
        }
        'repeat' {
            return receiver.repeat(int(e.value_as_int(args[0])!))
        }
        'replace' {
            return receiver.replace(e.expect_string_arg(args, 0)!, e.expect_string_arg(args, 1)!)
        }
        'split' {
            return ArrayValue{
                values: receiver.split(e.expect_string_arg(args, 0)!).map(Value(it))
            }
        }
        'starts_with' {
            return receiver.starts_with(e.expect_string_arg(args, 0)!)
        }
        'substr', 'substr_unsafe' {
            start := int(e.value_as_int(args[0])!)
            end := int(e.value_as_int(args[1])!)
            if start < 0 || end < start || end > receiver.len {
                return ''
            }
            substr := receiver[start..end]
            return substr
        }
        'substr_with_check' {
            start := int(e.value_as_int(args[0])!)
            end := int(e.value_as_int(args[1])!)
            if start < 0 || end < start || end > receiver.len {
                return wrap_result_err('substring out of bounds')
            }
            substr := receiver[start..end]
            return wrap_result_ok(substr)
        }
        'to_lower' {
            return receiver.to_lower()
        }
        'to_upper' {
            return receiver.to_upper()
        }
        'trim' {
            return receiver.trim(e.expect_string_arg(args, 0)!)
        }
        'trim_right' {
            return receiver.trim_right(e.expect_string_arg(args, 0)!)
        }
        'trim_space' {
            return receiver.trim_space()
        }
        else {
            return error('v2.eval: unsupported string method `${method_name}`')
        }
    }
}

fn (e &Eval) call_flags_method(method_name string, args []Value) !Value {
    _ = args
    return match method_name {
        'set', 'clear' { void_value() }
        'has' { Value(false) }
        else { error('v2.eval: unsupported flags method `${method_name}`') }
    }
}

fn (mut e Eval) call_array_method(receiver ArrayValue, method_name string, args []Value) !Value {
    match method_name {
        'has' {
            return e.array_has(receiver, safe_arg(args, 0))
        }
        'clone' {
            return ArrayValue{
                elem_type_name: receiver.elem_type_name
                values:         receiver.values.clone()
            }
        }
        'contains' {
            return e.array_contains(receiver, safe_arg(args, 0))
        }
        'first' {
            return e.array_first_value(receiver)
        }
        'index' {
            return e.array_index(receiver, safe_arg(args, 0), false)
        }
        'join' {
            sep := e.expect_string_arg(args, 0)!
            return receiver.values.map(e.value_string(it)).join(sep)
        }
        'last' {
            return e.array_last_value(receiver)
        }
        'last_index' {
            return e.array_index(receiver, safe_arg(args, 0), true)
        }
        'str' {
            return e.value_string(receiver)
        }
        else {
            return error('v2.eval: unsupported array method `${method_name}`')
        }
    }
}

fn (e &Eval) map_lookup(receiver MapValue, key Value) (Value, bool) {
    for entry in receiver.entries {
        if e.value_eq(entry.key, key) {
            return entry.value, true
        }
    }
    return receiver.default_value, false
}

fn (e &Eval) map_get_or_default(receiver MapValue, key Value) Value {
    value, found := e.map_lookup(receiver, key)
    if found {
        return value
    }
    return receiver.default_value
}

fn (e &Eval) map_contains_key(receiver MapValue, key Value) bool {
    _, found := e.map_lookup(receiver, key)
    return found
}

fn (e &Eval) map_set_value(receiver MapValue, key Value, value Value) MapValue {
    default_value := if receiver.default_value is VoidValue {
        e.zero_value_like(value)
    } else {
        receiver.default_value
    }
    mut entries := receiver.entries.clone()
    for i, entry in entries {
        if e.value_eq(entry.key, key) {
            entries[i] = MapEntry{
                key:   key
                value: value
            }
            return MapValue{
                default_value: default_value
                entries:       entries
            }
        }
    }
    entries << MapEntry{
        key:   key
        value: value
    }
    return MapValue{
        default_value: default_value
        entries:       entries
    }
}

fn (e &Eval) map_delete_value(receiver MapValue, key Value) MapValue {
    mut entries := []MapEntry{cap: receiver.entries.len}
    for entry in receiver.entries {
        if e.value_eq(entry.key, key) {
            continue
        }
        entries << entry
    }
    return MapValue{
        default_value: receiver.default_value
        entries:       entries
    }
}

fn (e &Eval) map_keys(receiver MapValue) ArrayValue {
    mut keys := []Value{cap: receiver.entries.len}
    for entry in receiver.entries {
        keys << entry.key
    }
    return ArrayValue{
        elem_type_name: e.infer_array_elem_type(keys)
        values:         keys
    }
}

fn (e &Eval) map_values(receiver MapValue) ArrayValue {
    mut values := []Value{cap: receiver.entries.len}
    for entry in receiver.entries {
        values << entry.value
    }
    elem_type_name := if receiver.default_value is VoidValue {
        e.infer_array_elem_type(values)
    } else {
        e.runtime_type_name(receiver.default_value)
    }
    return ArrayValue{
        elem_type_name: elem_type_name
        values:         values
    }
}

fn (e &Eval) map_clone(receiver MapValue) MapValue {
    return MapValue{
        default_value: receiver.default_value
        entries:       receiver.entries.clone()
    }
}

fn (e &Eval) map_clear(receiver MapValue) MapValue {
    return MapValue{
        default_value: receiver.default_value
        entries:       []MapEntry{}
    }
}

fn (e &Eval) zero_value_like(value Value) Value {
    return match value {
        ArrayValue {
            ArrayValue{}
        }
        FlagsValue {
            FlagsValue{}
        }
        MapValue {
            MapValue{
                default_value: e.zero_value_like(value.default_value)
            }
        }
        StructValue {
            e.zero_struct_value(value.type_name)
        }
        TupleValue {
            TupleValue{}
        }
        VoidValue {
            void_value()
        }
        bool {
            false
        }
        f64 {
            f64(0.0)
        }
        i64 {
            i64(0)
        }
        string {
            ''
        }
        else {
            void_value()
        }
    }
}

fn (e &Eval) zero_value_for_type_expr(expr ast.Expr) Value {
    match expr {
        ast.GenericArgs {
            if expr.lhs.name() == 'map' && expr.args.len == 2 {
                return MapValue{
                    default_value: e.zero_value_for_type_expr(expr.args[1])
                }
            }
            return StructValue{
                type_name: generic_args_name(expr)
                fields:    map[string]Value{}
            }
        }
        ast.Ident {
            if expr.name == 'bool' {
                return false
            }
            if expr.name in ['byte', 'char', 'i8', 'i16', 'i32', 'int', 'i64', 'isize', 'rune',
                'u8', 'u16', 'u32', 'u64', 'usize'] {
                return i64(0)
            }
            if expr.name in ['f32', 'f64'] {
                return f64(0.0)
            }
            if expr.name == 'string' {
                return ''
            }
            type_name := if e.has_type_name(e.current_module_name(), expr.name) {
                '${e.current_module_name()}.${expr.name}'
            } else {
                expr.name
            }
            return e.zero_struct_value(type_name)
        }
        ast.SelectorExpr {
            return e.zero_struct_value(expr.name())
        }
        ast.Type {
            return match expr {
                ast.ArrayFixedType, ast.ArrayType {
                    ArrayValue{}
                }
                ast.MapType {
                    MapValue{
                        default_value: e.zero_value_for_type_expr(expr.value_type)
                    }
                }
                ast.OptionType, ast.ResultType, ast.NilType, ast.NoneType {
                    void_value()
                }
                ast.TupleType {
                    TupleValue{
                        values: expr.types.map(e.zero_value_for_type_expr(it))
                    }
                }
                else {
                    e.zero_struct_value(e.type_node_name(expr))
                }
            }
        }
        else {
            return void_value()
        }
    }
}

fn (e &Eval) array_contains(receiver ArrayValue, needle Value) bool {
    for item in receiver.values {
        if e.value_eq(item, needle) {
            return true
        }
    }
    return false
}

fn (e &Eval) array_has(receiver ArrayValue, needle Value) bool {
    if e.array_contains(receiver, needle) {
        return true
    }
    if needle is string {
        for item in receiver.values {
            if item is StructValue {
                if name_value := item.fields['name'] {
                    if e.value_string(name_value) == needle {
                        return true
                    }
                }
            }
        }
    }
    return false
}

fn (e &Eval) array_index(receiver ArrayValue, needle Value, reverse bool) i64 {
    if reverse {
        for i := receiver.values.len - 1; i >= 0; i-- {
            if e.value_eq(receiver.values[i], needle) {
                return i64(i)
            }
        }
        return -1
    }
    for i, item in receiver.values {
        if e.value_eq(item, needle) {
            return i64(i)
        }
    }
    return -1
}

fn (e &Eval) array_first_value(receiver ArrayValue) !Value {
    if receiver.values.len == 0 {
        return error('v2.eval: array.first on empty array')
    }
    return receiver.values[0]
}

fn (e &Eval) array_last_value(receiver ArrayValue) !Value {
    if receiver.values.len == 0 {
        return error('v2.eval: array.last on empty array')
    }
    return receiver.values[receiver.values.len - 1]
}

fn (e &Eval) module_property(module_name string, field_name string) MaybeValue {
    if module_name == 'os' && field_name == 'args' {
        return MaybeValue{
            found: true
            value: ArrayValue{
                values: e.program_args().map(Value(it))
            }
        }
    }
    return MaybeValue{}
}

fn (e &Eval) program_args() []string {
    if e.prefs.eval_runtime_args.len > 0 {
        return e.prefs.eval_runtime_args
    }
    return os.args
}

fn (e &Eval) is_type_expr(expr ast.Expr) bool {
    match expr {
        ast.Ident {
            return e.is_builtin_type_name(expr.name)
                || e.has_type_name(e.current_module_name(), expr.name)
                || e.resolve_mangled_type_value(expr.name) != none || e.is_sum_type_name(expr.name)
        }
        ast.Type {
            return true
        }
        ast.GenericArgs {
            return true
        }
        else {
            return false
        }
    }
}

fn generic_args_name(expr ast.GenericArgs) string {
    mut parts := []string{cap: expr.args.len}
    for arg in expr.args {
        parts << arg.name()
    }
    return '${expr.lhs.name()}[${parts.join(',')}]'
}

fn (e &Eval) type_expr_name(expr ast.Expr) string {
    return match expr {
        ast.GenericArgs {
            generic_args_name(expr)
        }
        ast.Ident {
            expr.name
        }
        ast.ModifierExpr {
            e.type_expr_name(expr.expr)
        }
        ast.ParenExpr {
            e.type_expr_name(expr.expr)
        }
        ast.SelectorExpr {
            expr.name()
        }
        ast.Type {
            e.type_node_name(expr)
        }
        else {
            expr.name()
        }
    }
}

fn (e &Eval) type_node_name(typ ast.Type) string {
    return match typ {
        ast.AnonStructType {
            'struct'
        }
        ast.ArrayFixedType {
            '[${typ.len.name()}]${e.type_expr_name(typ.elem_type)}'
        }
        ast.ArrayType {
            '[]${e.type_expr_name(typ.elem_type)}'
        }
        ast.ChannelType {
            'chan ${e.type_expr_name(typ.elem_type)}'
        }
        ast.FnType {
            'fn'
        }
        ast.GenericType {
            '${typ.name.name()}[${typ.params.name_list()}]'
        }
        ast.MapType {
            'map[${e.type_expr_name(typ.key_type)}]${e.type_expr_name(typ.value_type)}'
        }
        ast.NilType {
            'nil'
        }
        ast.NoneType {
            'none'
        }
        ast.OptionType {
            '?${e.type_expr_name(typ.base_type)}'
        }
        ast.PointerType {
            if typ.lifetime != '' {
                '&^${typ.lifetime} ${e.type_expr_name(typ.base_type)}'
            } else {
                '&${e.type_expr_name(typ.base_type)}'
            }
        }
        ast.ResultType {
            '!${e.type_expr_name(typ.base_type)}'
        }
        ast.ThreadType {
            if typ.elem_type is ast.EmptyExpr {
                'thread'
            } else {
                'thread ${e.type_expr_name(typ.elem_type)}'
            }
        }
        ast.TupleType {
            '(' + typ.types.map(e.type_expr_name(it)).join(',') + ')'
        }
    }
}

fn (e &Eval) is_builtin_type_name(name string) bool {
    return name in ['bool', 'byte', 'char', 'f32', 'f64', 'i8', 'i16', 'i32', 'int', 'i64', 'isize',
        'rune', 'string', 'u8', 'u16', 'u32', 'u64', 'usize', 'voidptr', 'byteptr']
}

fn (e &Eval) is_ref_type_name(name string) bool {
    trimmed := name.trim_space()
    if trimmed == '' {
        return false
    }
    if trimmed.starts_with('&') || trimmed.starts_with('[]') || trimmed.starts_with('map[')
        || trimmed.starts_with('fn') || trimmed.starts_with('thread ')
        || trimmed in ['array', 'map', 'module', 'range', 'tuple', 'type', 'void'] {
        return true
    }
    if trimmed.starts_with('?') || trimmed.starts_with('!') {
        return e.is_ref_type_name(trimmed[1..])
    }
    if e.is_builtin_type_name(trimmed) {
        return false
    }
    return trimmed.contains('.')
}

fn (e &Eval) sizeof_type_name(name string) i64 {
    trimmed := name.trim_space()
    if trimmed == '' {
        return 0
    }
    if trimmed.starts_with('?') || trimmed.starts_with('!') {
        return e.sizeof_type_name(trimmed[1..])
    }
    if trimmed.starts_with('&') || trimmed.ends_with('*') || trimmed == 'voidptr'
        || trimmed == 'byteptr' || trimmed.starts_with('fn') {
        return 8
    }
    if trimmed.starts_with('[]') || trimmed == 'array' || trimmed.ends_with('Builder')
        || trimmed.ends_with('.Builder') {
        return 24
    }
    if trimmed.starts_with('map[') || trimmed == 'map' {
        return 32
    }
    if trimmed.starts_with('chan ') || trimmed.starts_with('thread ') {
        return 8
    }
    return match trimmed {
        'bool', 'byte', 'char', 'i8', 'u8' {
            1
        }
        'i16', 'u16' {
            2
        }
        'f32', 'i32', 'int', 'rune', 'u32' {
            4
        }
        'f64', 'i64', 'isize', 'u64', 'usize' {
            8
        }
        'string' {
            16
        }
        'flags' {
            4
        }
        'module', 'range', 'tuple', 'type', 'void' {
            8
        }
        else {
            if trimmed.contains('.') || trimmed == 'struct' {
                8
            } else {
                0
            }
        }
    }
}

fn (e &Eval) cast_value(value Value, type_name string) !Value {
    if info := e.sum_type_info(type_name) {
        if e.is_existing_sumtype_wrapper(value, type_name) {
            return value
        }
        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(type_name, info, inferred.tag, payload)
            }
        }
        if nested := e.infer_nested_sumtype_variant(info, value) {
            return e.build_sumtype_wrapper(type_name, info, nested.tag, nested.payload)
        }
        if tag := e.sumtype_tag_from_value(info, value) {
            return e.build_sumtype_wrapper(type_name, info, tag, value)
        }
    }
    match type_name {
        'bool' {
            return e.value_as_bool(value)!
        }
        'byte', 'char', 'i8', 'i16', 'int', 'i64', 'rune', 'u8', 'u16', 'u32', 'u64' {
            return e.value_as_int(value)!
        }
        'f32', 'f64' {
            return e.value_as_f64(value)!
        }
        'string' {
            return e.value_string(value)
        }
        else {
            if value is StructValue {
                if payload := e.unwrap_sumtype_value(value, type_name) {
                    return payload
                }
                return StructValue{
                    type_name: type_name
                    fields:    value.fields.clone()
                }
            }
            return value
        }
    }
}

fn (e &Eval) type_name_matches(actual string, expected string) bool {
    if actual == expected {
        return true
    }
    mut actual_module := ''
    if actual.contains('.') {
        actual_module = actual.all_before_last('.')
    }
    for alias in e.type_name_aliases(actual_module, actual) {
        if alias == expected {
            return true
        }
    }
    mut expected_module := ''
    if expected.contains('.') {
        expected_module = expected.all_before_last('.')
    }
    for alias in e.type_name_aliases(expected_module, expected) {
        if alias == actual {
            return true
        }
    }
    return false
}

fn (e &Eval) value_matches_type_name(value Value, target_name string) bool {
    match value {
        ArrayValue {
            return target_name == 'array' || target_name.starts_with('[]')
        }
        FlagsValue {
            return target_name == 'flags'
        }
        MapValue {
            return target_name == 'map' || target_name.starts_with('map[')
        }
        ModuleValue {
            return target_name == 'module'
        }
        RangeValue {
            return target_name == 'range'
        }
        StructValue {
            return e.type_name_matches(value.type_name, target_name)
        }
        TupleValue {
            return target_name == 'tuple'
        }
        TypeValue {
            return target_name == 'type' || value.name == target_name
        }
        VoidValue {
            return target_name in ['none', 'nil', 'void']
        }
        bool {
            return target_name == 'bool'
        }
        f64 {
            return target_name in ['f32', 'f64']
        }
        i64 {
            return target_name in ['byte', 'char', 'i8', 'i16', 'i32', 'int', 'i64', 'isize', 'rune',
                'u8', 'u16', 'u32', 'u64', 'usize']
        }
        string {
            return target_name == 'string'
        }
    }
}

fn (e &Eval) expect_string_arg(args []Value, index int) !string {
    if index >= args.len {
        return error('v2.eval: missing argument ${index}')
    }
    value := args[index]
    if value is string {
        return value
    }
    return e.value_string(value)
}

fn (e &Eval) value_to_string_array(value Value) ![]string {
    if value is ArrayValue {
        vals := value.values
        return vals.map(e.value_string(it))
    }
    return error('v2.eval: expected []string-compatible value')
}

fn (e &Eval) value_to_byte_array(value Value) ![]u8 {
    if value !is ArrayValue {
        return error('v2.eval: expected []u8-compatible value')
    }
    array_value := value as ArrayValue
    mut bytes := []u8{cap: array_value.values.len}
    for item in array_value.values {
        bytes << u8(e.value_as_int(item)!)
    }
    return bytes
}

fn (e &Eval) array_args_to_strings(args []Value) []string {
    mut out := []string{}
    for arg in args {
        if arg is ArrayValue {
            for item in arg.values {
                out << e.value_string(item)
            }
            continue
        }
        out << e.value_string(arg)
    }
    return out
}

fn (e &Eval) value_as_bool(value Value) !bool {
    return match value {
        bool { value }
        i64 { value != 0 }
        f64 { value_f64_payload(value) != 0.0 }
        string { value.len > 0 }
        ArrayValue { value.values.len > 0 }
        FlagsValue { false }
        MapValue { value.entries.len > 0 }
        StructValue { value.fields.len > 0 }
        VoidValue { false }
        else { return error('v2.eval: `${e.runtime_type_name(value)}` can not be used as bool') }
    }
}

fn (e &Eval) value_as_int(value Value) !i64 {
    return match value {
        i64 {
            value
        }
        f64 {
            i64(value_f64_payload(value))
        }
        bool {
            if value {
                i64(1)
            } else {
                i64(0)
            }
        }
        string {
            strconv.parse_int(value, 0, 64)!
        }
        FlagsValue {
            i64(0)
        }
        else {
            return error('v2.eval: `${e.runtime_type_name(value)}` can not be used as int in `${e.current_function_label()}` stack `${e.call_stack_trace()}`')
        }
    }
}

fn (e &Eval) value_as_f64(value Value) !f64 {
    return match value {
        f64 {
            value_f64_payload(value)
        }
        i64 {
            f64(value)
        }
        bool {
            if value {
                1.0
            } else {
                0.0
            }
        }
        string {
            strconv.atof64(value)!
        }
        else {
            return error('v2.eval: `${e.runtime_type_name(value)}` can not be used as float')
        }
    }
}

fn (e &Eval) map_entry_string(entry MapEntry) string {
    key_text := if entry.key is string {
        "'${entry.key}'"
    } else {
        e.value_string(entry.key)
    }
    return '${key_text}: ${e.value_string(entry.value)}'
}

fn (e &Eval) value_string(value Value) string {
    return match value {
        ArrayValue {
            vals := value.values
            '[' + vals.map(e.value_string(it)).join(', ') + ']'
        }
        FlagsValue {
            'flags'
        }
        MapValue {
            '{' + value.entries.map(e.map_entry_string(it)).join(', ') + '}'
        }
        ModuleValue {
            value.name
        }
        RangeValue {
            rs := value.start
            re := value.end
            sep := if value.inclusive { '...' } else { '..' }
            '${rs}${sep}${re}'
        }
        StructValue {
            keys := value.fields.keys()

            '${value.type_name}{' + keys.map('${it}: ${e.value_string(value.fields[it] or {
                void_value()
            })}').join(', ') + '}'
        }
        TupleValue {
            vals := value.values
            '(' + vals.map(e.value_string(it)).join(', ') + ')'
        }
        TypeValue {
            value.name
        }
        VoidValue {
            ''
        }
        bool, i64, string {
            value.str()
        }
        f64 {
            value_f64_payload(value).str()
        }
    }
}

fn (e &Eval) runtime_type_name(value Value) string {
    return match value {
        ArrayValue { 'array' }
        FlagsValue { 'flags' }
        MapValue { 'map' }
        ModuleValue { 'module' }
        RangeValue { 'range' }
        StructValue { value.type_name }
        TupleValue { 'tuple' }
        TypeValue { 'type' }
        VoidValue { 'void' }
        bool { 'bool' }
        f64 { 'f64' }
        i64 { 'int' }
        string { 'string' }
    }
}

fn (mut e Eval) write_stdout(s string) {
    if e.capture_output {
        e.stdout_data += s
    } else {
        print(s)
    }
}

fn (mut e Eval) write_stderr(s string) {
    if e.capture_output {
        e.stderr_data += s
    } else {
        eprint(s)
    }
}