// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module c

import v.ast
import v.util
import v.token

fn smartcast_selector_expr_str(expr ast.SelectorExpr) string {
    mut expr_str := expr.expr.str()
    if expr.expr is ast.ParExpr && expr.expr.expr is ast.AsCast {
        expr_str = expr.expr.expr.expr.str()
    }
    return expr_str
}

fn (g &Gen) is_smartcast_assign_lhs(expr ast.Expr) bool {
    match expr {
        ast.Ident {
            if expr.obj is ast.Var && expr.obj.smartcasts.len > 0 {
                if expr.obj.is_mut && expr.obj.orig_type != 0 {
                    orig_sym := g.table.final_sym(expr.obj.orig_type)
                    if orig_sym.kind == .sum_type {
                        return false
                    }
                }
                return true
            }
            return false
        }
        ast.SelectorExpr {
            if expr.expr_type == 0 {
                return false
            }
            scope_field := expr.scope.find_struct_field(smartcast_selector_expr_str(expr),
                expr.expr_type, expr.field_name)
            if scope_field == unsafe { nil } || scope_field.smartcasts.len == 0 {
                return false
            }
            // Option field smartcast on LHS: the assignment replaces the option
            // as a whole (e.g. `s.x = 10` or `s.x = none` inside `if s.x != none`),
            // so skip unwrap treatment that's only meant for sumtype reassignments.
            if scope_field.orig_type.has_flag(.option) {
                return false
            }
            return true
        }
        else {
            return false
        }
    }
}

fn (mut g Gen) expr_in_value_context(expr ast.Expr, value_type ast.Type, expected_type ast.Type) {
    mut expr_copy := expr
    match mut expr_copy {
        ast.IfExpr {
            if !expr_copy.is_expr || expr_copy.typ == 0 || expr_copy.typ == ast.void_type {
                expr_copy.is_expr = true
                expr_copy.typ = if value_type != 0 && value_type != ast.void_type {
                    value_type
                } else {
                    expected_type
                }
            }
        }
        ast.MatchExpr {
            if !expr_copy.is_expr || expr_copy.return_type == 0
                || expr_copy.return_type == ast.void_type {
                resolved_value_type := if value_type != 0 && value_type != ast.void_type {
                    value_type
                } else {
                    expected_type
                }
                expr_copy.is_expr = true
                expr_copy.return_type = resolved_value_type
                if expr_copy.expected_type in [0, ast.void_type, ast.none_type] {
                    expr_copy.expected_type = expected_type
                }
            }
        }
        else {}
    }

    if expected_type.has_flag(.shared_f) && !value_type.has_flag(.shared_f) && value_type.is_ptr()
        && !expected_type.has_option_or_result() {
        g.expr_with_cast(expr_copy, value_type, expected_type)
        return
    }
    g.expr(expr_copy)
}

fn (mut g Gen) auto_heap_assignment_uses_existing_storage(expr ast.Expr, expr_type ast.Type) bool {
    // Reusing container-backed storage avoids leaking a fresh HEAP() copy for
    // `@[heap]` values like `x := arr[i]`. Keep the old path under autofree,
    // because aliasing array storage there would hand ownership to the local.
    if g.is_autofree {
        return false
    }
    return match expr {
        ast.IndexExpr { g.auto_heap_array_index_uses_existing_storage(expr, expr_type) }
        else { false }
    }
}

fn (mut g Gen) auto_heap_array_index_uses_existing_storage(node ast.IndexExpr, expr_type ast.Type) bool {
    if node.index is ast.RangeExpr || node.or_expr.kind != .absent || node.is_option {
        return false
    }
    mut resolved_expr_type := g.recheck_concrete_type(g.resolved_expr_type(ast.Expr(node),
        expr_type))
    if resolved_expr_type == 0 || resolved_expr_type == ast.void_type {
        resolved_expr_type = g.recheck_concrete_type(expr_type)
    }
    if resolved_expr_type == 0 || resolved_expr_type == ast.void_type {
        resolved_expr_type = g.recheck_concrete_type(node.typ)
    }
    elem_type := g.unwrap_generic(resolved_expr_type)
    if elem_type == 0 || elem_type.is_ptr() || !g.table.final_sym(elem_type).is_heap() {
        return false
    }
    mut resolved_left_type := g.recheck_concrete_type(g.resolved_expr_type(node.left,
        node.left_type))
    if resolved_left_type == 0 || resolved_left_type == ast.void_type {
        resolved_left_type = g.recheck_concrete_type(node.left_type)
    }
    left_sym := g.table.final_sym(g.unwrap_generic(resolved_left_type))
    return left_sym.kind == .array
}

fn (mut g Gen) write_auto_heap_assignment_expr(expr ast.Expr, expr_type ast.Type) bool {
    return match expr {
        ast.IndexExpr { g.write_auto_heap_array_index_expr(expr, expr_type) }
        else { false }
    }
}

fn (mut g Gen) write_auto_heap_array_index_expr(node ast.IndexExpr, expr_type ast.Type) bool {
    if !g.auto_heap_array_index_uses_existing_storage(node, expr_type) {
        return false
    }
    mut resolved_expr_type := g.recheck_concrete_type(g.resolved_expr_type(ast.Expr(node),
        expr_type))
    if resolved_expr_type == 0 || resolved_expr_type == ast.void_type {
        resolved_expr_type = g.recheck_concrete_type(expr_type)
    }
    if resolved_expr_type == 0 || resolved_expr_type == ast.void_type {
        resolved_expr_type = g.recheck_concrete_type(node.typ)
    }
    elem_type := g.unwrap_generic(resolved_expr_type)
    elem_type_str := g.styp(elem_type)
    mut resolved_left_type := g.recheck_concrete_type(g.resolved_expr_type(node.left,
        node.left_type))
    if resolved_left_type == 0 || resolved_left_type == ast.void_type {
        resolved_left_type = g.recheck_concrete_type(node.left_type)
    }
    left_type := if resolved_left_type != 0 { resolved_left_type } else { node.left_type }
    left_is_ptr := left_type.is_ptr() || node.left.is_auto_deref_var()
    left_is_shared := left_type.has_flag(.shared_f)
    array_get_fn := if node.is_gated { 'builtin__array_get_ni' } else { 'builtin__array_get' }
    g.write('((${elem_type_str}*)${array_get_fn}(')
    if left_is_ptr && !left_is_shared {
        g.write('*')
    }
    if node.left is ast.IndexExpr {
        g.inside_array_index = true
        g.expr(ast.Expr(node.left))
        g.inside_array_index = false
    } else {
        g.expr(ast.Expr(node.left))
    }
    if left_is_shared {
        if left_is_ptr {
            g.write('->val')
        } else {
            g.write('.val')
        }
    }
    g.write(', ')
    g.expr(node.index)
    g.write('))')
    return true
}

fn (mut g Gen) write_assign_target_expr(left ast.Expr, var_type ast.Type) {
    if left.is_auto_deref_var() && !var_type.has_flag(.shared_f) {
        g.write('*')
    }
    g.expr(left)
    if var_type.has_flag(.shared_f) {
        g.write('->val')
    }
}

fn (mut g Gen) write_assign_value_expr(left ast.Expr, var_type ast.Type) {
    old_is_assign_lhs := g.is_assign_lhs
    g.is_assign_lhs = false
    defer {
        g.is_assign_lhs = old_is_assign_lhs
    }
    if left.is_auto_deref_var() && !var_type.has_flag(.shared_f) {
        g.write('*')
    }
    g.expr(left)
    if var_type.has_flag(.shared_f) {
        g.write('->val')
    }
}

fn (mut g Gen) gen_power_assign_expr(left ast.Expr, left_type ast.Type, right ast.Expr, right_type ast.Type) {
    power_result_type := g.normalized_power_result_type(left_type.clear_flag(.shared_f).clear_flag(.atomic_f),
        left_type.clear_flag(.shared_f).clear_flag(.atomic_f), right_type)
    builtin_power_type := g.table.unalias_num_type(power_result_type)
    result_styp := g.styp(power_result_type)
    g.uses_power = true
    if builtin_power_type == ast.f32_type {
        g.write('(${result_styp})powf((${g.styp(ast.f32_type)})(')
        g.write_assign_value_expr(left, left_type)
        g.write('), ')
        g.expr_with_cast(right, right_type, ast.f32_type)
        g.write(')')
        return
    }
    if builtin_power_type.is_float() {
        g.write('(${result_styp})pow((${g.styp(ast.f64_type)})(')
        g.write_assign_value_expr(left, left_type)
        g.write('), ')
        g.expr_with_cast(right, right_type, ast.f64_type)
        g.write(')')
        return
    }
    if builtin_power_type.is_unsigned() {
        g.uses_power_u64 = true
        g.write('(${result_styp})__v_pow_u64((${g.styp(ast.u64_type)})(')
        g.write_assign_value_expr(left, left_type)
        g.write('), ')
        g.expr_with_cast(right, right_type, ast.i64_type)
        g.write(')')
        return
    }
    g.write('(${result_styp})__v_pow_i64((${g.styp(ast.i64_type)})(')
    g.write_assign_value_expr(left, left_type)
    g.write('), ')
    g.expr_with_cast(right, right_type, ast.i64_type)
    g.write(')')
}

fn assign_expr_unwraps_option_or_result(expr ast.Expr) bool {
    return match expr {
        ast.CallExpr { expr.or_block.kind != .absent }
        ast.ComptimeCall { expr.or_block.kind != .absent }
        ast.ComptimeSelector { expr.or_block.kind != .absent }
        ast.Ident { expr.or_expr.kind != .absent }
        ast.IndexExpr { expr.or_expr.kind != .absent && !expr.typ.has_option_or_result() }
        ast.InfixExpr { expr.or_block.kind != .absent }
        ast.PostfixExpr { expr.op == .question }
        ast.PrefixExpr { expr.or_block.kind != .absent }
        ast.SelectorExpr { expr.or_block.kind != .absent }
        else { false }
    }
}

fn (mut g Gen) decl_assign_struct_init_needs_tmp(expr ast.Expr) bool {
    mut node := ast.StructInit{}
    match expr {
        ast.StructInit {
            node = expr
        }
        ast.ParExpr {
            if expr.expr !is ast.StructInit {
                return false
            }
            node = expr.expr as ast.StructInit
        }
        else {
            return false
        }
    }

    sym := g.table.final_sym(g.unwrap_generic(g.recheck_concrete_type(node.typ)))
    if sym.info !is ast.Struct {
        return false
    }
    if g.styp(node.typ) in skip_struct_init {
        return false
    }
    info := sym.info as ast.Struct
    if node.no_keys {
        return node.init_fields.len < info.fields.len
    }
    init_field_names := node.init_fields.map(it.name)
    return info.fields.any(it.name !in init_field_names)
}

fn (mut g Gen) gen_self_recursing_anon_fn_capture_patch(left ast.Expr, anon_fn ast.AnonFn) {
    if left !is ast.Ident || anon_fn.inherited_vars.len == 0 {
        return
    }
    ident := left as ast.Ident
    if ident.name !in anon_fn.inherited_vars.map(it.name) {
        return
    }
    ctx_struct := g.closure_ctx(anon_fn.decl)
    left_expr := g.expr_string(left)
    g.writeln('((${ctx_struct}*)builtin__closure__closure_data(${left_expr}))->${c_name(ident.name)} = ${left_expr};')
}

fn (mut g Gen) expr_with_opt_or_block(expr ast.Expr, expr_typ ast.Type, var_expr ast.Expr, ret_typ ast.Type,
    in_heap bool) {
    gen_or := expr is ast.Ident && expr.or_expr.kind != .absent
    if gen_or {
        old_inside_opt_or_res := g.inside_opt_or_res
        g.inside_opt_or_res = true
        expr_var := if expr is ast.Ident && expr.kind == .constant {
            g.c_const_name(expr.name)
        } else if expr is ast.Ident && expr.is_auto_heap() {
            '(*${expr.name})'
        } else {
            '${expr}'
        }
        dot_or_ptr := if !expr_typ.has_flag(.option_mut_param_t) { '.' } else { '-> ' }
        mut heap_line := ''
        if in_heap {
            // When the variable needs heap allocation, the caller has already
            // written the partial line `TYPE *var = HEAP(TYPE, (`.
            // We must NOT access the option's .data inside the HEAP macro
            // before checking the state, because the option may be `none`.
            // Pull back the partial line, emit the state check first, then
            // write the assignment with data access after the check.
            heap_line = g.go_before_last_stmt()
            g.empty_line = true
        } else {
            g.expr_with_cast(expr, expr_typ, ret_typ)
            g.writeln(';')
        }
        g.writeln('if (${c_name(expr_var)}${dot_or_ptr}state != 0) { // assign')
        if expr is ast.Ident && expr.or_expr.kind == .propagate_option {
            g.writeln('\tbuiltin__panic_option_not_set(_S("none"));')
        } else {
            g.inside_or_block = true
            defer {
                g.inside_or_block = false
            }
            or_expr := (expr as ast.Ident).or_expr
            stmts := or_expr.stmts
            scope := or_expr.scope
            last_stmt := stmts.last()
            // handles stmt block which returns something
            // e.g. { return none }
            if stmts.len > 0 && last_stmt is ast.ExprStmt && last_stmt.typ != ast.void_type {
                var_expr_name := c_name(var_expr.str())
                if last_stmt.expr is ast.Ident && last_stmt.expr.or_expr.kind != .absent {
                    g.write('${var_expr_name} = ')
                    g.expr_with_opt_or_block(ast.Expr(last_stmt.expr), last_stmt.typ, var_expr,
                        ret_typ, in_heap)
                } else {
                    g.gen_or_block_stmts(var_expr_name, '', stmts, ret_typ, false, scope,
                        expr.pos())
                }
            } else {
                // handles stmt block which doesn't returns value
                // e.g. { return }
                g.stmts(stmts)
                if stmts.len > 0 && last_stmt is ast.ExprStmt {
                    g.writeln(';')
                }
                g.write_defer_stmts(scope, false, expr.pos())
            }
        }
        g.writeln('}')
        if in_heap {
            // Now that the state has been checked (and we haven't returned/panicked),
            // it is safe to access .data and do the heap allocation.
            g.write(heap_line)
            g.expr_with_cast(expr, expr_typ, ret_typ)
            g.writeln('));')
        }
        g.inside_opt_or_res = old_inside_opt_or_res
    } else {
        g.expr_with_opt(expr, expr_typ, ret_typ)
        if in_heap {
            g.write('))')
        }
    }
}

// expr_opt_with_alias handles conversion from different option alias type name
fn (mut g Gen) expr_opt_with_alias(expr ast.Expr, expr_typ ast.Type, ret_typ ast.Type) string {
    styp := g.base_type(ret_typ)

    line := g.go_before_last_stmt().trim_space()
    g.empty_line = true

    ret_var := g.new_tmp_var()
    ret_styp := g.styp(ret_typ).replace('*', '_ptr')
    g.writeln('${ret_styp} ${ret_var} = {.state=2, .err=_const_none__, .data={E_STRUCT}};')

    if expr !is ast.None {
        is_option_expr := expr_typ.has_flag(.option)
        if is_option_expr {
            g.write('builtin___option_clone((${option_name}*)')
        } else {
            g.write('builtin___option_ok(&(${styp}[]){ ')
        }
        has_addr := is_option_expr && expr !in [ast.Ident, ast.SelectorExpr]
        if has_addr {
            expr_styp := g.styp(expr_typ).replace('*', '_ptr')
            g.write('ADDR(${expr_styp}, ')
        } else if is_option_expr {
            g.write('&')
        }
        g.expr(expr)
        if has_addr {
            g.write(')')
        }
        if !is_option_expr {
            g.write(' }')
        }
        g.writeln(', (${option_name}*)&${ret_var}, sizeof(${styp}));')
    }
    g.write(line)
    if g.inside_return {
        g.write(' ')
    }
    g.write(ret_var)
    return ret_var
}

// expr_opt_with_cast is used in cast expr when converting compatible option types
// e.g. ?int(?u8(0))
fn (mut g Gen) expr_opt_with_cast(expr ast.Expr, expr_typ ast.Type, ret_typ ast.Type) string {
    if !expr_typ.has_flag(.option) || !ret_typ.has_flag(.option) {
        panic('cgen: expected expr_type and ret_typ to be options')
    }

    if expr_typ.idx() == ret_typ.idx() && g.table.sym(expr_typ).kind != .alias {
        return g.expr_with_opt(expr, expr_typ, ret_typ)
    } else {
        if expr is ast.CallExpr && expr.return_type.has_flag(.option) {
            return g.expr_opt_with_alias(expr, expr_typ, ret_typ)
        } else {
            past := g.past_tmp_var_new()
            defer {
                g.past_tmp_var_done(past)
            }
            unwrapped_ret := g.unwrap_generic(ret_typ)
            // Unwrap type aliases to ensure sizeof uses the base type size, not the alias size
            // This fixes the ASAN stack-buffer-overflow issue when using type aliases like MaybeInt = ?int
            unaliased_ret := g.table.unaliased_type(unwrapped_ret)
            styp := g.base_type(unaliased_ret)
            decl_styp := g.styp(unwrapped_ret).replace('*', '_ptr')
            g.writeln('${decl_styp} ${past.tmp_var};')
            is_none := expr is ast.CastExpr && expr.expr is ast.None
            if is_none {
                g.write('builtin___option_none(&(${styp}[]) {')
            } else {
                g.write('builtin___option_ok(&(${styp}[]) {')
            }
            if expr is ast.CastExpr && expr_typ.has_flag(.option) {
                ret_sym := g.table.sym(ret_typ)
                if ret_sym.kind == .sum_type {
                    exp_sym := g.table.sym(expr_typ)
                    fname := g.get_sumtype_casting_fn(expr_typ, ret_typ)
                    g.call_cfn_for_casting_expr(fname, expr, ret_typ, expr_typ, expr_typ,
                        ret_sym.cname, expr_typ.is_ptr(), exp_sym.kind == .function,
                        g.styp(expr_typ))
                } else {
                    g.write('*((${g.base_type(expr_typ)}*)')
                    g.expr(expr)
                    g.write('.data)')
                }
            } else {
                old_inside_opt_or_res := g.inside_opt_or_res
                g.inside_opt_or_res = false
                g.expr_with_cast(expr, expr_typ, ret_typ)
                g.inside_opt_or_res = old_inside_opt_or_res
            }
            g.writeln(' }, (${option_name}*)(&${past.tmp_var}), sizeof(${styp}));')
            return past.tmp_var
        }
    }
}

// expr_with_opt is used in assigning an expression to an `option` variable
// e.g. x = y (option lhs and rhs), mut x = ?int(123), y = none
fn (mut g Gen) expr_with_opt(expr ast.Expr, expr_typ ast.Type, ret_typ ast.Type) string {
    old_inside_opt_or_res := g.inside_opt_or_res
    g.inside_opt_or_res = true
    defer {
        g.inside_opt_or_res = old_inside_opt_or_res
    }
    unwrapped_expr_typ := g.unwrap_generic(expr_typ)
    unwrapped_ret_typ := g.unwrap_generic(ret_typ)
    if unwrapped_expr_typ.has_flag(.option) && unwrapped_ret_typ.has_flag(.option)
        && !g.is_arraymap_set
        && expr in [ast.SelectorExpr, ast.DumpExpr, ast.Ident, ast.ComptimeSelector, ast.ComptimeCall, ast.AsCast, ast.CallExpr, ast.MatchExpr, ast.IfExpr, ast.IndexExpr, ast.UnsafeExpr, ast.CastExpr] {
        if expr in [ast.Ident, ast.CastExpr] {
            if unwrapped_expr_typ.idx() != unwrapped_ret_typ.idx()
                && g.table.type_to_str(unwrapped_expr_typ) != g.table.type_to_str(unwrapped_ret_typ) {
                return g.expr_opt_with_cast(expr, unwrapped_expr_typ, unwrapped_ret_typ)
            }
        }
        g.expr(expr)
        if expr is ast.ComptimeSelector {
            return g.gen_comptime_selector(expr)
        } else {
            return expr.str()
        }
    } else {
        tmp_out_var := g.new_tmp_var()
        g.expr_with_tmp_var(expr, unwrapped_expr_typ, unwrapped_ret_typ, tmp_out_var, true)
        return tmp_out_var
    }
    return ''
}

fn (g &Gen) static_init_guard_name(pos token.Pos) string {
    return '_vstatic_init_${pos.pos}'
}

fn (mut g Gen) gen_static_decl_runtime_init(node ast.AssignStmt, left ast.Expr, left_type ast.Type, right ast.Expr, right_type ast.Type) bool {
    if node.left.len != 1 || node.right.len != 1 || g.inside_ternary != 0 {
        return false
    }
    if left !is ast.Ident {
        return false
    }
    guard_name := g.static_init_guard_name(left.pos())
    g.writeln(';')
    g.writeln('static bool ${guard_name};')
    g.writeln('if (!${guard_name}) {')
    g.indent++
    g.writeln('${guard_name} = true;')
    old_is_assign_lhs := g.is_assign_lhs
    g.is_assign_lhs = false
    g.assign_stmt(ast.AssignStmt{
        op:          .assign
        pos:         node.pos
        left:        [left]
        right:       [right]
        left_types:  [left_type]
        right_types: [right_type]
    })
    g.is_assign_lhs = old_is_assign_lhs
    g.indent--
    g.writeln('}')
    return true
}

fn (mut g Gen) assign_stmt(node_ ast.AssignStmt) {
    mut node := unsafe { node_ }
    if node.is_static {
        is_defer_var := node.left[0] is ast.Ident && node.left[0].name in g.defer_vars
        if is_defer_var && node.op == .decl_assign {
            return
        }
        if !is_defer_var {
            g.write('static ')
        }
    }
    if node.is_volatile && node.left[0] is ast.Ident && node.left[0].name !in g.defer_vars {
        g.write('volatile ')
    }
    mut return_type := ast.void_type
    is_decl := node.op == .decl_assign
    g.assign_op = node.op
    g.inside_assign = true
    g.arraymap_set_pos = 0
    g.is_arraymap_set = false
    g.is_assign_lhs = false
    g.is_shared = false
    defer {
        g.assign_op = .unknown
        g.inside_assign = false
        g.assign_ct_type.clear()
        g.expected_rhs_type_by_pos.clear()
        g.arraymap_set_pos = 0
        g.is_arraymap_set = false
        g.is_assign_lhs = false
        g.is_shared = false
    }
    op := if is_decl { token.Kind.assign } else { node.op }
    right_expr := node.right[0]
    match right_expr {
        ast.CallExpr {
            resolved_call_type := g.resolve_return_type(right_expr)
            if resolved_call_type != ast.void_type {
                return_type = resolved_call_type
            } else {
                return_type = right_expr.return_type
            }
        }
        ast.LockExpr {
            return_type = right_expr.typ
        }
        ast.MatchExpr {
            return_type = right_expr.return_type
        }
        ast.IfExpr {
            return_type = right_expr.typ
        }
        else {}
    }

    if node.right.len == 1 && node.left.len > 1 && node.left_types.len == node.left.len {
        is_generic_context := g.cur_fn != unsafe { nil } && g.cur_concrete_types.len > 0
        concrete_left_types := if is_generic_context {
            node.left_types.map(g.unwrap_generic(g.recheck_concrete_type(it)))
        } else {
            node.left_types
        }
        if concrete_left_types.all(it != 0 && !it.has_flag(.generic)
            && !g.type_has_unresolved_generic_parts(it))
        {
            expected_multi_return := g.table.find_or_register_multi_return(concrete_left_types)
            if return_type == ast.void_type || return_type == 0 {
                return_type = expected_multi_return
            } else if g.table.sym(return_type).kind == .multi_return
                && return_type != expected_multi_return {
                actual_return_types := if is_generic_context {
                    (g.table.sym(return_type).info as ast.MultiReturn).types.map(g.unwrap_generic(g.recheck_concrete_type(it)))
                } else {
                    (g.table.sym(return_type).info as ast.MultiReturn).types
                }
                if actual_return_types.any(it == 0 || it.has_flag(.generic)
                    || g.type_has_unresolved_generic_parts(it))
                {
                    return_type = expected_multi_return
                }
            }
        }
    }
    // Free the old value assigned to this string var (only if it's `str = [new value]`
    // or `x.str = [new value]` )
    mut af := g.is_autofree && !g.is_builtin_mod && !g.is_autofree_tmp && node.left_types.len == 1
        && node.left[0] in [ast.Ident, ast.SelectorExpr] && (node.op == .assign
        || (node.op == .plus_assign && node.left_types[0] == ast.string_type))
    if af && node.right.len == 1 && node.right[0] is ast.CallExpr {
        call_expr := node.right[0] as ast.CallExpr
        if call_expr.is_method && call_expr.left is ast.CallExpr {
            af = false
        }
    }
    mut sref_name := ''
    mut type_to_free := ''
    if af {
        first_left_type := node.left_types[0]
        first_left_sym := g.table.sym(node.left_types[0])
        if first_left_type == ast.string_type
            || (node.op == .assign && first_left_sym.kind == .array) {
            type_to_free = if first_left_type == ast.string_type { 'string' } else { 'array' }
            mut ok := true
            left0 := node.left[0]
            if left0 is ast.Ident {
                if left0.name == '_' {
                    ok = false
                }
            }
            if ok {
                sref_name = '_sref${node.pos.pos}'
                g.write('${type_to_free} ${sref_name} = (') // TODO: we are copying the entire string here, optimize
                // we can't just do `.str` since we need the extra data from the string struct
                // doing `&string` is also not an option since the stack memory with the data will be overwritten
                if left0.is_auto_deref_var() && !first_left_type.has_flag(.shared_f) {
                    g.write('*')
                }
                g.expr(left0) // node.left[0])
                if first_left_type.has_flag(.shared_f) {
                    g.write('->val')
                }
                g.writeln('); // free ${type_to_free} on re-assignment2')
                defer(fn) {
                    if af {
                        g.writeln('builtin__${type_to_free}_free(&${sref_name});')
                    }
                }
            } else {
                af = false
            }
        } else {
            af = false
        }
    }
    // TODO: g.gen_assign_vars_autofree(node)
    // json_test failed w/o this check
    if node.right.len == 1 && return_type != ast.void_type && return_type != 0 {
        sym := g.table.sym(return_type)
        if sym.kind == .multi_return {
            g.gen_multi_return_assign(node, return_type, sym)
            return
        }
    }
    // TODO: non idents on left (exprs)
    if node.has_cross_var {
        g.gen_cross_var_assign(node)
    }
    // `a := 1` | `a,b := 1,2`
    if node.right.len < node.left.len {
        g.checker_bug('node.right.len < node.left.len', node.pos)
    }
    if node.right_types.len < node.left.len {
        g.checker_bug('node.right_types.len < node.left.len', node.pos)
    }
    if node.left_types.len < node.left.len {
        g.checker_bug('node.left_types.len < node.left.len', node.pos)
    }

    last_curr_var_name := g.curr_var_name.clone()
    defer {
        g.curr_var_name = last_curr_var_name
    }
    g.curr_var_name = []

    for i, mut left in node.left {
        mut is_auto_heap := false
        mut is_fn_var := false
        mut var_type := node.left_types[i]
        mut val_type := node.right_types[i]
        // Save original shared status of val_type before resolution blocks can overwrite it.
        // This is needed because `val_type = var_type` in resolution blocks can lose the
        // RHS shared flag (e.g., lock expr returning shared value to non-shared variable).
        orig_val_shared := val_type.has_flag(.shared_f)
        if g.cur_fn != unsafe { nil } && g.cur_concrete_types.len > 0 {
            resolved_left_type := g.recheck_concrete_type(var_type)
            if resolved_left_type != 0 {
                var_type = g.unwrap_generic(resolved_left_type)
            }
            resolved_right_type := g.recheck_concrete_type(val_type)
            if resolved_right_type != 0 {
                val_type = g.unwrap_generic(resolved_right_type)
            }
        }
        mut val := node.right[i]
        expected_lhs_type := var_type
        if expected_lhs_type != 0 && expected_lhs_type != ast.void_type
            && !expected_lhs_type.has_option_or_result() && val in [ast.IfExpr, ast.MatchExpr] {
            g.expected_rhs_type_by_pos[val.pos().pos] = expected_lhs_type
        }
        mut str_add_rhs_tmp := ''
        mut str_add_rhs_needs_free := false
        mut skip_str_add_rhs_clone := false
        if is_decl && g.cur_concrete_types.len > 0 && val is ast.CallExpr
            && val.return_type_generic != 0 {
            mut resolved_val_type := g.resolve_return_type(val).clear_option_and_result()
            if resolved_val_type == ast.void_type || resolved_val_type.has_flag(.generic) {
                resolved_val_type =
                    g.unwrap_generic(val.return_type_generic).clear_option_and_result()
            }
            // When unwrap_generic couldn't resolve (e.g. cur_fn.generic_names is empty
            // for methods whose generics come from the receiver), try resolving using
            // the receiver's generic type names from the current fn.
            if (resolved_val_type == ast.void_type || resolved_val_type.has_flag(.generic)
                || g.type_has_unresolved_generic_parts(resolved_val_type))
                && g.cur_fn != unsafe { nil } && g.cur_fn.is_method
                && g.cur_fn.receiver.typ.has_flag(.generic) {
                receiver_generic_names := g.table.generic_type_names(g.cur_fn.receiver.typ)
                if receiver_generic_names.len == g.cur_concrete_types.len {
                    if gen_type := g.table.convert_generic_type(val.return_type_generic,
                        receiver_generic_names, g.cur_concrete_types)
                    {
                        resolved_val_type = gen_type.clear_option_and_result()
                    }
                }
            }
            if resolved_val_type != ast.void_type && !resolved_val_type.has_flag(.generic) {
                var_type = ast.mktyp(resolved_val_type)
                val_type = resolved_val_type
            }
        }
        mut is_call := false
        mut gen_or := false
        mut blank_assign := false
        mut is_va_list := false // C varargs
        mut ident := ast.Ident{
            scope: unsafe { nil }
        }
        if is_decl {
            // Strip shared/atomic flags and pointer from the default type
            // so that `resolved_expr_type` doesn't propagate LHS declaration
            // properties to the resolved RHS type (e.g., for string/int literals
            // that fall through to the default).
            mut decl_default := var_type.clear_flag(.shared_f).clear_flag(.atomic_f)
            if var_type.has_flag(.shared_f) && decl_default.nr_muls() > 0 {
                decl_default = decl_default.set_nr_muls(decl_default.nr_muls() - 1)
            }
            // Check if this variable is auto-heap promoted early so we can
            // skip resolved_expr_type updates that would add extra pointer
            // levels (the HEAP macro handles the pointer promotion).
            left_is_auto_heap := left is ast.Ident && g.resolved_ident_is_auto_heap_not_stack(left)
            resolved_decl_type := g.resolved_expr_type(val, decl_default)
            if resolved_decl_type != 0 && resolved_decl_type != ast.void_type && !left_is_auto_heap {
                mut resolved_unwrapped :=
                    g.unwrap_generic(g.recheck_concrete_type(resolved_decl_type))
                // Don't propagate pointer flag from auto-deref mut parameters.
                // `mut e := expr` where expr is a mut param should create a value copy.
                // Also handles the case where var_type is already a pointer (e.g.
                // `c := head` where head is `mut &Client` → var_type is &Client
                // but resolved_expr_type returns &&Client). Compare nr_muls to
                // deref only when there's an extra level from auto-deref.
                if resolved_unwrapped.is_ptr() && !var_type.is_ptr() {
                    resolved_unwrapped = resolved_unwrapped.deref()
                } else if val is ast.Ident && val.is_auto_deref_var()
                    && resolved_unwrapped.nr_muls() > var_type.nr_muls() {
                    resolved_unwrapped = resolved_unwrapped.set_nr_muls(var_type.nr_muls())
                }
                // Don't propagate shared/atomic flags from the resolved RHS expression
                // to a non-shared declaration. E.g., `sliced := shared_arr[..x]` inside
                // a rlock block resolves to a shared type, but `sliced` is not shared.
                if !var_type.has_flag(.shared_f) && resolved_unwrapped.has_flag(.shared_f) {
                    resolved_unwrapped = resolved_unwrapped.clear_flag(.shared_f)
                    if resolved_unwrapped.nr_muls() > 0 {
                        resolved_unwrapped =
                            resolved_unwrapped.set_nr_muls(resolved_unwrapped.nr_muls() - 1)
                    }
                }
                if !var_type.has_flag(.atomic_f) && resolved_unwrapped.has_flag(.atomic_f) {
                    resolved_unwrapped = resolved_unwrapped.clear_flag(.atomic_f)
                }
                // Skip when resolved type is a parent sumtype of a smartcast variant.
                // This happens in match arms where the RHS uses a smartcast variable
                // (e.g. `mut info := ts.info` inside `match ts.info { Struct { ... } }`).
                // Resolve aggregate types (from multi-branch match arms)
                // to the concrete variant type for the current iteration.
                resolved_sym_ := g.table.sym(resolved_unwrapped)
                if resolved_sym_.info is ast.Aggregate {
                    resolved_unwrapped = resolved_sym_.info.types[g.aggregate_type_idx]
                }
                resolved_sym := g.table.sym(resolved_unwrapped)
                var_sym := g.table.sym(var_type)
                is_sumtype_reversal := resolved_sym.kind == .sum_type
                    && resolved_unwrapped != var_type && var_sym.kind != .sum_type
                // Don't downgrade a specific map/array type (e.g. map[int]SqlExpr)
                // to the base map/array type. This happens when .clone() etc.
                // return the base type but the checker already has a specific type.
                is_base_container_downgrade := (resolved_unwrapped == ast.map_type
                    && var_sym.kind == .map && var_type != ast.map_type)
                    || (resolved_unwrapped == ast.array_type && var_sym.kind == .array
                    && var_type != ast.array_type)
                // Don't introduce option/result flag when the checker already unwrapped it.
                // E.g., `x := *var?` where var is `?&int`: checker says x is `int`,
                // but resolved_expr_type may return `?int` because it sees the option var.
                is_option_introduction := !var_type.has_option_or_result()
                    && resolved_unwrapped.has_option_or_result()
                if !is_sumtype_reversal && !is_base_container_downgrade && !is_option_introduction {
                    var_type = resolved_unwrapped
                    val_type = var_type
                    node.left_types[i] = var_type
                    if i < node.right_types.len {
                        node.right_types[i] = val_type
                    }
                    if mut left is ast.Ident {
                        if mut left.obj is ast.Var {
                            left.obj.typ = var_type
                            if !var_type.has_option_or_result() {
                                left.obj.orig_type = ast.no_type
                                left.obj.smartcasts = []
                                left.obj.is_unwrapped = false
                            }
                            if left.obj.ct_type_var != .no_comptime {
                                g.type_resolver.update_ct_type(left.name, var_type)
                            }
                        }
                        if left.scope != unsafe { nil } {
                            if mut scope_var := left.scope.find_var(left.name) {
                                scope_var.typ = var_type
                                if !var_type.has_option_or_result() {
                                    scope_var.orig_type = ast.no_type
                                    scope_var.smartcasts = []
                                    scope_var.is_unwrapped = false
                                }
                            }
                        }
                    }
                }
            }
        }
        mut cur_indexexpr := -1
        consider_int_overflow := g.do_int_overflow_checks && g.unwrap_generic(var_type).is_int()
        consider_int_div_mod := g.table.final_sym(g.unwrap_generic(var_type)).is_int()
        is_safe_add_assign := node.op == .plus_assign && consider_int_overflow
        is_safe_sub_assign := node.op == .minus_assign && consider_int_overflow
        is_safe_mul_assign := node.op == .mult_assign && consider_int_overflow
        is_safe_div_assign := node.op == .div_assign && consider_int_div_mod
        is_safe_mod_assign := node.op == .mod_assign && consider_int_div_mod
        initial_left_sym := g.table.sym(g.unwrap_generic(var_type))
        is_va_list = initial_left_sym.language == .c && initial_left_sym.name == 'C.va_list'
        if mut left is ast.Ident {
            ident = left
            g.curr_var_name << ident.name
            // id_info := ident.var_info()
            // var_type = id_info.typ
            blank_assign = left.kind == .blank_ident
            // TODO: temporary, remove this
            left_info := left.info
            if left_info is ast.IdentVar {
                share := left_info.share
                if share == .shared_t {
                    var_type = var_type.set_flag(.shared_f)
                }
                if share == .atomic_t {
                    var_type = var_type.set_flag(.atomic_f)
                }
            }
            if mut left.obj is ast.Var {
                if is_decl {
                    if val is ast.Ident && val.ct_expr {
                        ctyp := g.unwrap_generic(g.type_resolver.get_type(val))
                        if ctyp != ast.void_type {
                            var_type = ctyp
                            val_type = var_type
                            gen_or = val.or_expr.kind != .absent
                            if gen_or {
                                var_type = val_type.clear_flag(.option)
                            }
                            left.obj.typ = var_type
                            g.type_resolver.update_ct_type(left.name, var_type)
                        }
                    } else if val is ast.ComptimeSelector {
                        if val.typ_key != '' {
                            if is_decl {
                                var_type = g.type_resolver.get_ct_type_or_default(val.typ_key,
                                    var_type)
                                val_type = var_type
                                left.obj.typ = var_type
                                g.type_resolver.update_ct_type(left.name, var_type)
                            } else {
                                val_type = g.type_resolver.get_ct_type_or_default(val.typ_key,
                                    var_type)
                            }
                        }
                    } else if val is ast.ComptimeCall {
                        var_type = if val.kind in [.zero, .new] {
                            g.comptime_zero_new_result_type(val, var_type)
                        } else {
                            key_str := '${val.method_name}.return_type'
                            g.type_resolver.get_ct_type_or_default(key_str, var_type)
                        }
                        val_type = var_type
                        left.obj.typ = var_type
                        g.type_resolver.update_ct_type(left.name, var_type)
                        g.assign_ct_type[val.pos.pos] = var_type
                    } else if val is ast.Ident && val.info is ast.IdentVar {
                        val_info := val.info as ast.IdentVar
                        gen_or = val.or_expr.kind != .absent
                        if val_info.is_option && gen_or {
                            var_type = val_type.clear_flag(.option)
                            left.obj.typ = var_type
                        }
                    } else if val is ast.DumpExpr {
                        if val.expr is ast.ComptimeSelector {
                            if val.expr.typ_key != '' {
                                var_type = g.type_resolver.get_ct_type_or_default(val.expr.typ_key,
                                    var_type)
                                val_type = var_type
                                left.obj.typ = var_type
                                g.type_resolver.update_ct_type(left.name, var_type)
                            }
                        }
                    } else if val is ast.IndexExpr && (val.left is ast.Ident && val.left.ct_expr) {
                        ctyp := g.unwrap_generic(g.type_resolver.get_type(val))
                        if ctyp != ast.void_type {
                            var_type = ctyp
                            val_type = var_type
                            left.obj.typ = var_type
                            g.type_resolver.update_ct_type(left.name, var_type)
                        }
                    } else if left.obj.ct_type_var == .generic_var && val is ast.CallExpr {
                        if val.return_type_generic != 0 {
                            mut fn_ret_type := g.resolve_return_type(val).clear_option_and_result()
                            if fn_ret_type == ast.void_type || fn_ret_type.has_flag(.generic) {
                                fn_ret_type =
                                    g.unwrap_generic(val.return_type_generic).clear_option_and_result()
                            }
                            if fn_ret_type != ast.void_type {
                                var_type = fn_ret_type
                                val_type = var_type
                                left.obj.typ = var_type
                                g.assign_ct_type[val.pos.pos] = var_type
                            }
                        } else if val.is_static_method && val.left_type.has_flag(.generic) {
                            fn_ret_type := g.resolve_return_type(val)
                            var_type = fn_ret_type
                            val_type = var_type
                            left.obj.typ = var_type
                            g.assign_ct_type[val.pos.pos] = var_type
                        } else if val.left_type != 0 && g.table.type_kind(val.left_type) == .array
                            && val.name == 'map' && val.args.len > 0
                            && val.args[0].expr is ast.AsCast
                            && val.args[0].expr.typ.has_flag(.generic) {
                            var_type =
                                g.table.find_or_register_array(g.unwrap_generic((val.args[0].expr as ast.AsCast).typ))
                            val_type = var_type
                            left.obj.typ = var_type
                            g.assign_ct_type[val.pos.pos] = var_type
                        }
                    } else if val is ast.InfixExpr
                        && val.op in [.plus, .minus, .mul, .power, .div, .mod] && val.left_ct_expr {
                        left_ctyp := g.type_resolver.get_type_or_default(val.left, val.left_type)
                        right_ctyp := g.type_resolver.get_type_or_default(val.right, val.right_type)
                        ctyp := g.type_resolver.promote_type(g.unwrap_generic(left_ctyp),
                            g.unwrap_generic(right_ctyp))
                        if ctyp != ast.void_type {
                            ct_type_var := g.comptime.get_ct_type_var(val.left)
                            if ct_type_var in [.key_var, .value_var] {
                                g.type_resolver.update_ct_type(left.name, g.unwrap_generic(ctyp))
                            }
                            var_type = ctyp
                            val_type = var_type
                            left.obj.typ = var_type
                        }
                    } else if val is ast.PostfixExpr && val.op == .question
                        && (val.expr is ast.Ident && val.expr.ct_expr) {
                        ctyp := g.unwrap_generic(g.type_resolver.get_type(val))
                        if ctyp != ast.void_type {
                            var_type = ctyp
                            val_type = var_type
                            left.obj.typ = var_type

                            ct_type_var := g.comptime.get_ct_type_var(val.expr)
                            if ct_type_var == .field_var {
                                g.type_resolver.update_ct_type(left.name, ctyp)
                            }
                        }
                    } else if var_type.has_flag(.generic) && val is ast.StructInit
                        && val_type.has_flag(.generic) {
                        val_type = g.unwrap_generic(val_type)
                        var_type = val_type
                    }
                }
                is_auto_heap = g.resolved_ident_is_auto_heap(left)
                // In generic instantiations, is_auto_heap may be set by the
                // checker's post_process when concrete types resolve to @[heap]
                // structs. Reset when the variable is an option type.
                if is_auto_heap && g.cur_fn != unsafe { nil } && g.cur_concrete_types.len > 0 {
                    resolved_obj_typ := g.unwrap_generic(left.obj.typ)
                    if resolved_obj_typ != 0 && resolved_obj_typ.has_flag(.option)
                        && !resolved_obj_typ.is_ptr() {
                        is_auto_heap = false
                    }
                }
                if left.obj.typ != 0 && val is ast.PrefixExpr {
                    is_fn_var = g.table.final_sym(left.obj.typ).kind == .function
                }
            }
        } else if mut left is ast.ComptimeSelector {
            if left.typ_key != '' {
                var_type = g.type_resolver.get_ct_type_or_default(left.typ_key, var_type)
            }
            if val is ast.ComptimeSelector {
                if val.typ_key != '' {
                    val_type = g.type_resolver.get_ct_type_or_default(val.typ_key, var_type)
                }
            } else if val is ast.CallExpr && val.return_type_generic.has_flag(.generic) {
                g.assign_ct_type[val.pos.pos] = g.comptime.comptime_for_field_type
                val_type = var_type
            }
        } else if mut left is ast.IndexExpr && val is ast.ComptimeSelector {
            if val.typ_key != '' {
                val_type = g.type_resolver.get_ct_type_or_default(val.typ_key, var_type)
            }
        }
        if is_decl && val is ast.CallExpr && val.or_block.kind != .absent {
            mut resolved_call_type := g.resolve_return_type(val)
            if resolved_call_type == ast.void_type {
                resolved_call_type = val.return_type
            }
            if g.table.sym(resolved_call_type).kind == .alias {
                unaliased_call_type := g.table.unaliased_type(resolved_call_type)
                if unaliased_call_type.has_option_or_result() {
                    resolved_call_type = g.unwrap_generic(unaliased_call_type)
                }
            }
            var_type = resolved_call_type.clear_option_and_result()
            val_type = var_type
            if mut left is ast.Ident && mut left.obj is ast.Var {
                left.obj.typ = var_type
            }
        }
        if is_decl && val is ast.PostfixExpr && val.op == .question {
            mut resolved_val_type := g.resolved_expr_type(val.expr, val_type)
            if g.table.sym(resolved_val_type).kind == .alias {
                unaliased_val_type := g.table.unaliased_type(resolved_val_type)
                if unaliased_val_type.has_option_or_result() {
                    resolved_val_type = g.unwrap_generic(unaliased_val_type)
                }
            }
            resolved_val_type = resolved_val_type.clear_option_and_result()
            if resolved_val_type != 0 && resolved_val_type != ast.void_type {
                var_type = resolved_val_type
                val_type = resolved_val_type
                if mut left is ast.Ident && mut left.obj is ast.Var {
                    left.obj.typ = var_type
                }
            }
        }
        if is_decl && val is ast.Ident && val.or_expr.kind != .absent && g.cur_fn != unsafe { nil }
            && g.cur_concrete_types.len > 0 && val.or_expr.stmts.len > 0 {
            last_or_stmt := val.or_expr.stmts.last()
            if last_or_stmt is ast.ExprStmt && last_or_stmt.typ != ast.void_type {
                resolved_or_type := g.resolved_expr_type(last_or_stmt.expr, last_or_stmt.typ)
                if resolved_or_type != 0 && resolved_or_type != ast.void_type {
                    var_type = g.unwrap_generic(g.recheck_concrete_type(resolved_or_type))
                    val_type = var_type
                    if mut left is ast.Ident && mut left.obj is ast.Var {
                        left.obj.typ = var_type
                    }
                }
            }
        }
        if is_decl && assign_expr_unwraps_option_or_result(val) {
            var_type = var_type.clear_option_and_result()
            val_type = val_type.clear_option_and_result()
            if mut left is ast.Ident && mut left.obj is ast.Var {
                left.obj.typ = var_type
            }
        }
        if is_decl && var_type.has_option_or_result() {
            if (val is ast.CallExpr && val.or_block.kind != .absent)
                || (val is ast.PostfixExpr && val.op == .question) {
                var_type = var_type.clear_option_and_result()
                val_type = val_type.clear_option_and_result()
                if mut left is ast.Ident && mut left.obj is ast.Var {
                    left.obj.typ = var_type
                }
            }
        }
        if is_decl && mut left is ast.Ident && mut left.obj is ast.Var {
            mut should_recompute_decl_type := false
            match val {
                ast.Ident {
                    should_recompute_decl_type = val.ct_expr
                        || (val.obj is ast.Var && val.obj.ct_type_var != .no_comptime)
                        || (val.obj is ast.Var && (val.obj.typ.has_flag(.generic)
                        || g.type_has_unresolved_generic_parts(val.obj.typ)))
                }
                ast.SelectorExpr {
                    should_recompute_decl_type = val.typ.has_flag(.generic)
                        || g.type_has_unresolved_generic_parts(val.typ)
                        || val.expr_type.has_flag(.generic)
                        || g.type_has_unresolved_generic_parts(val.expr_type)
                }
                ast.IndexExpr {
                    should_recompute_decl_type = val.typ.has_flag(.generic)
                        || g.type_has_unresolved_generic_parts(val.typ)
                        || val.left_type.has_flag(.generic)
                        || g.type_has_unresolved_generic_parts(val.left_type)
                        || (val.left is ast.Ident && val.left.ct_expr)
                }
                ast.ComptimeSelector {
                    should_recompute_decl_type = true
                }
                ast.ComptimeCall {
                    should_recompute_decl_type = val.kind in [.zero, .new]
                }
                ast.CastExpr {
                    should_recompute_decl_type = val.typ.has_flag(.generic)
                        || g.type_has_unresolved_generic_parts(val.typ)
                }
                ast.PostfixExpr {
                    should_recompute_decl_type = val.op == .question
                }
                ast.PrefixExpr {
                    should_recompute_decl_type = val.op == .arrow
                }
                else {}
            }

            if g.cur_fn != unsafe { nil } && g.cur_concrete_types.len > 0 {
                should_recompute_decl_type = true
            }
            if val is ast.CallExpr {
                should_recompute_decl_type = val.return_type_generic != 0
                    || val.is_static_method || val.concrete_types.len > 0
                    || val.raw_concrete_types.len > 0
                    || (g.cur_fn != unsafe { nil } && g.cur_concrete_types.len > 0)
                    || (val.is_method && (val.left_type.has_flag(.generic)
                    || g.type_has_unresolved_generic_parts(val.left_type)
                    || val.receiver_type.has_flag(.generic)
                    || g.type_has_unresolved_generic_parts(val.receiver_type)))
            }
            mut resolved_val_type := if val is ast.ComptimeCall && val.kind in [.zero, .new] {
                g.comptime_zero_new_result_type(val, val_type)
            } else if val is ast.Ident && val.or_expr.kind != .absent && g.cur_fn != unsafe { nil }
                && g.cur_concrete_types.len > 0 {
                or_value_type := g.resolved_or_block_value_type(val.or_expr)
                if or_value_type != 0 {
                    or_value_type
                } else {
                    g.resolved_expr_type(val, val_type)
                }
            } else {
                g.resolved_expr_type(val, val_type)
            }
            if should_recompute_decl_type && resolved_val_type != 0
                && resolved_val_type != ast.void_type {
                if assign_expr_unwraps_option_or_result(val) {
                    resolved_val_type = resolved_val_type.clear_option_and_result()
                }
                resolved_val_type = g.unwrap_generic(g.recheck_concrete_type(resolved_val_type))
                // Resolve aggregate types (from multi-branch match arms)
                // to the concrete variant type for the current iteration.
                resolved_val_sym2 := g.table.sym(resolved_val_type)
                if resolved_val_sym2.info is ast.Aggregate {
                    resolved_val_type = resolved_val_sym2.info.types[g.aggregate_type_idx]
                }
                // For SelectorExpr with scope smartcast (e.g. `if w.check != none`),
                // the resolved field type has the option flag, but the smartcast
                // unwraps it. Clear the option flag in that case.
                if val is ast.SelectorExpr && resolved_val_type.has_flag(.option) {
                    scope := g.file.scope.innermost(val.pos.pos)
                    field := scope.find_struct_field(val.expr.str(), val.expr_type, val.field_name)
                    if field != unsafe { nil } && field.smartcasts.len > 0 {
                        resolved_val_type = resolved_val_type.clear_flag(.option)
                    }
                }
                resolved_val_sym := g.table.final_sym(resolved_val_type)
                if resolved_val_sym.kind == .array && !resolved_val_type.is_ptr()
                    && g.table.sym(resolved_val_type).kind != .alias {
                    mut resolved_elem_type :=
                        g.unwrap_generic(g.recheck_concrete_type(resolved_val_sym.array_info().elem_type))
                    if resolved_elem_type == ast.int_literal_type {
                        resolved_elem_type = ast.int_type
                    } else if resolved_elem_type == ast.float_literal_type {
                        resolved_elem_type = ast.f64_type
                    }
                    if resolved_elem_type != 0 && !resolved_elem_type.has_flag(.generic)
                        && !g.type_has_unresolved_generic_parts(resolved_elem_type) {
                        mut new_arr_type :=
                            ast.idx_to_type(g.table.find_or_register_array(resolved_elem_type))
                        // Preserve option/result flags from the original resolved type
                        if resolved_val_type.has_flag(.option) {
                            new_arr_type = new_arr_type.set_flag(.option)
                        }
                        if resolved_val_type.has_flag(.result) {
                            new_arr_type = new_arr_type.set_flag(.result)
                        }
                        resolved_val_type = new_arr_type
                    }
                }
                // When assigning from an auto-deref variable (e.g. mut ref param),
                // the resolved type from scope includes the extra pointer level.
                // Deref it to match the V value semantics.
                if val is ast.Ident && val.is_auto_deref_var() && resolved_val_type.is_ptr()
                    && !g.auto_deref_source_type_is_pointer(val) {
                    resolved_val_type = resolved_val_type.deref()
                }
                // Preserve shared/atomic flags from the original declaration.
                if var_type.has_flag(.shared_f) {
                    resolved_val_type = resolved_val_type.set_flag(.shared_f)
                }
                if var_type.has_flag(.atomic_f) {
                    resolved_val_type = resolved_val_type.set_flag(.atomic_f)
                }
                var_type = resolved_val_type
                // val_type represents the RHS expression type, which is NOT shared/atomic.
                // Only var_type (the LHS declaration type) should carry those flags.
                val_type = resolved_val_type.clear_flag(.shared_f).clear_flag(.atomic_f)
                left.obj.typ = var_type
            }
        }
        // Various resolution blocks above may overwrite var_type, stripping the
        // shared/atomic flags and nr_muls that the checker originally set.
        // Re-apply them based on the left-hand identifier's share attribute,
        // which is the authoritative source for whether the declaration is shared.
        if is_decl && mut left is ast.Ident {
            left_info := left.info
            if left_info is ast.IdentVar {
                if left_info.share == .shared_t && !var_type.has_flag(.shared_f) {
                    var_type = var_type.set_flag(.shared_f)
                }
                if left_info.share == .atomic_t && !var_type.has_flag(.atomic_f) {
                    var_type = var_type.set_flag(.atomic_f)
                }
            }
        }
        if is_decl && var_type.has_flag(.shared_f) && var_type.nr_muls() == 0 {
            var_type = var_type.set_nr_muls(1)
        }
        if is_decl && mut left is ast.Ident && mut left.obj is ast.Var {
            left.obj.typ = var_type
            if mut scope_var := left.scope.find_var(left.name) {
                scope_var.typ = var_type
                scope_var.orig_type = ast.no_type
                scope_var.smartcasts = []
                scope_var.is_unwrapped = false
            }
        }
        if is_decl && val is ast.CallExpr && val.kind == .clone && val.left is ast.IndexExpr {
            left_idx := val.left as ast.IndexExpr
            if left_idx.index is ast.RangeExpr && g.table.final_sym(var_type).kind == .array {
                is_auto_heap = false
            }
        }
        mut styp := g.styp(var_type)
        if is_decl && val is ast.CallExpr && val.kind == .clone && val.left is ast.IndexExpr {
            left_idx := val.left as ast.IndexExpr
            if left_idx.index is ast.RangeExpr && g.table.final_sym(val.return_type).kind == .array {
                styp = styp.trim('*')
            }
        }
        mut is_fixed_array_init := false
        mut has_val := false
        match val {
            ast.ArrayInit {
                is_fixed_array_init = val.is_fixed
                has_val = val.has_val
            }
            ast.ParExpr {
                if val.expr is ast.ArrayInit {
                    array_init := val.expr as ast.ArrayInit
                    is_fixed_array_init = array_init.is_fixed
                    has_val = array_init.has_val
                }
            }
            ast.CallExpr {
                is_call = true
                if val.comptime_ret_val {
                    return_type = g.comptime.comptime_for_field_type
                    styp = g.styp(return_type)
                } else {
                    return_type = val.return_type
                }
            }
            // TODO: no buffer fiddling
            ast.AnonFn {
                if !var_type.has_option_or_result() {
                    if blank_assign {
                        g.write('{')
                    }
                    // if it's a decl assign (`:=`) or a blank assignment `_ =`/`_ :=` then generate `void (*ident) (args) =`
                    if (is_decl || blank_assign) && left is ast.Ident {
                        sig := g.fn_var_signature(val.typ, val.decl.return_type,
                            val.decl.params.map(it.typ), ident.name)
                        g.write(sig + ' = ')
                    } else {
                        g.is_assign_lhs = true
                        g.assign_op = node.op
                        g.expr(left)
                        g.is_assign_lhs = false
                        g.is_arraymap_set = false
                        if mut left is ast.IndexExpr {
                            sym := g.table.final_sym(left.left_type)
                            if sym.kind in [.map, .array] {
                                g.expr(val)
                                g.writeln('});')
                                continue
                            }
                        }
                        g.write(' = ')
                    }
                    g.expr(val)
                    g.writeln(';')
                    g.gen_self_recursing_anon_fn_capture_patch(left, val)
                    if blank_assign {
                        g.write('}')
                    }
                    continue
                }
            }
            else {}
        }

        if g.cur_fn != unsafe { nil } && g.cur_concrete_types.len > 0 {
            orig_var_option := var_type.has_flag(.option)
            resolved_left_type := g.resolved_expr_type(left, var_type)
            if resolved_left_type != 0 {
                var_type = g.unwrap_generic(g.recheck_concrete_type(resolved_left_type))
            }
            // Preserve the option flag when the variable was option-smartcasted.
            // `resolved_expr_type` returns the smartcasted (unwrapped) type for variables
            // inside `if x != none` blocks, but the C variable is still the option type
            // and needs option wrapping on assignment.
            if orig_var_option && !var_type.has_flag(.option) {
                var_type = var_type.set_flag(.option)
            }
            resolved_val_type := g.resolved_expr_type(val, val_type)
            if resolved_val_type != 0 {
                new_val_type := g.unwrap_generic(g.recheck_concrete_type(resolved_val_type))
                // Preserve option/result flag clearing from earlier unwrap
                if !val_type.has_flag(.option) && new_val_type.has_flag(.option) {
                    val_type = new_val_type.clear_option_and_result()
                } else if !val_type.has_flag(.result) && new_val_type.has_flag(.result) {
                    val_type = new_val_type.clear_option_and_result()
                } else {
                    val_type = new_val_type
                }
            }
        }
        styp = g.styp(var_type)
        if is_decl && val is ast.CallExpr && val.kind == .clone && val.left is ast.IndexExpr {
            left_idx := val.left as ast.IndexExpr
            if left_idx.index is ast.RangeExpr && g.table.final_sym(val.return_type).kind == .array {
                styp = styp.trim('*')
            }
        }
        left_sym := g.table.sym(g.unwrap_generic(var_type))
        is_va_list = left_sym.language == .c && left_sym.name == 'C.va_list'
        unwrapped_val_type := g.unwrap_generic(val_type)
        right_sym := g.table.sym(unwrapped_val_type)
        unaliased_right_sym := g.table.final_sym(unwrapped_val_type)
        unaliased_left_sym := g.table.final_sym(g.unwrap_generic(var_type))
        is_fixed_array_var := unaliased_right_sym.kind == .array_fixed && val !is ast.ArrayInit
            && (val in [ast.Ident, ast.IndexExpr, ast.CallExpr, ast.SelectorExpr, ast.ComptimeSelector, ast.DumpExpr, ast.InfixExpr]
            || (val is ast.CastExpr && val.expr !is ast.ArrayInit)
            || (val is ast.PrefixExpr && val.op == .arrow)
            || (val is ast.UnsafeExpr && val.expr in [ast.SelectorExpr, ast.Ident, ast.CallExpr]))
            && !((g.pref.translated || g.file.is_translated)
            && unaliased_left_sym.kind != .array_fixed)
        g.is_assign_lhs = true
        g.assign_op = node.op

        g.left_is_opt = var_type.has_option_or_result()
        g.right_is_opt = val_type.has_option_or_result()
        defer(fn) {
            g.left_is_opt = false
            g.right_is_opt = false
        }
        if !is_decl && node.op == .assign && var_type.has_flag(.option_mut_param_t) {
            // For `mut ?T` parameters / for-loop variables, the C type is
            // `_option_T*` (pointer to option). Write through the pointer
            // by copying the entire option struct (state + data).
            mut target_option_type := g.resolve_current_fn_generic_param_type(left.str())
            if target_option_type == 0 || !target_option_type.has_flag(.option) {
                target_option_type = var_type.clear_flag(.option_mut_param_t)
            }
            if target_option_type.has_flag(.option) {
                target_inner_type := target_option_type.clear_option_and_result()
                if target_inner_type.is_ptr() {
                    target_option_type = target_inner_type.deref().set_flag(.option)
                }
            }
            target_option_type = g.unwrap_generic(g.recheck_concrete_type(target_option_type))
            tmp_var := g.new_tmp_var()
            g.expr_with_tmp_var(val, val_type, target_option_type, tmp_var, false)
            left_name := c_name(left.str())
            is_fn_param := left is ast.Ident && left.is_auto_deref_var()
            if is_fn_param {
                // Function params use _option_T* type, copy data through pointer
                val_base_type := g.base_type(val_type)
                g.writeln('${left_name}->state = ${tmp_var}.state;')
                g.writeln('memcpy(&${left_name}->data, ${tmp_var}.data, sizeof(${val_base_type}));')
            } else {
                // For-loop variables use _option_T* type, copy whole struct
                g.writeln('*${left_name} = ${tmp_var};')
            }
            continue
        }

        if blank_assign {
            if val is ast.IndexExpr {
                g.assign_op = .decl_assign
            }
            g.is_assign_lhs = false
            if is_call {
                old_is_void_expr_stmt := g.is_void_expr_stmt
                g.is_void_expr_stmt = true
                g.expr(val)
                g.is_void_expr_stmt = old_is_void_expr_stmt
            } else if g.inside_for_c_stmt {
                g.expr(val)
            } else if var_type.has_flag(.option) {
                // Blank ident option types can be stale across generic instantiations.
                // Use the actual RHS option type when it is available so `_ = val`
                // does not rewrap the expression into a mismatched option payload.
                blank_option_type := if val_type.has_flag(.option) { val_type } else { var_type }
                g.expr_with_opt(val, val_type, blank_option_type)
            } else {
                if left_sym.kind == .function {
                    g.write('{void* _ = ')
                } else {
                    // For blank idents, use val_type to determine the C type
                    // instead of var_type (styp), because in generic functions
                    // the checker's left_types[i] for blank idents can be
                    // overwritten by a later generic instantiation.
                    mut blank_styp := g.styp(val_type)
                    if val is ast.Ident && val.is_auto_deref_var()
                        && !g.auto_deref_source_type_is_pointer(val) {
                        blank_styp = '${blank_styp}*'
                    }
                    if blank_styp.ends_with('*') {
                        blank_styp = 'void*'
                    }
                    g.write('{${blank_styp} _ = ')
                }
                if (val in [ast.MatchExpr, ast.IfExpr, ast.ComptimeSelector] || is_fixed_array_var)
                    && unaliased_right_sym.info is ast.ArrayFixed {
                    tmp_var := g.expr_with_var(val, var_type, false)
                    // When the temp var is a return wrapper struct (_v_Array_fixed_...),
                    // access .ret_arr to get the actual C array for subscripting.
                    init_expr := if unaliased_right_sym.info.is_fn_ret {
                        '${tmp_var}.ret_arr'
                    } else {
                        tmp_var
                    }
                    g.fixed_array_var_init(init_expr, false, unaliased_right_sym.info.elem_type,
                        unaliased_right_sym.info.size)
                } else {
                    g.expr(val)
                }
                g.writeln(';}')
            }
        } else if node.op == .assign && (is_fixed_array_init || is_fixed_array_var
            || (unaliased_right_sym.kind == .array_fixed && val is ast.CastExpr)) {
            // Fixed arrays
            if unaliased_left_sym.kind != .array_fixed && unaliased_right_sym.kind == .array_fixed
                && (g.pref.translated || g.file.is_translated) {
                // translated:
                // arr = [5]u8{}
                // ptr = arr   => ptr = &arr[0]
                g.expr(left)
                g.write(' = ')
                g.expr(val)
            } else if is_fixed_array_init && var_type.has_flag(.option) {
                g.expr(left)
                g.write(' = ')
                g.expr_with_opt(val, val_type, var_type)
            } else if unaliased_right_sym.kind == .array_fixed && val is ast.CastExpr {
                if var_type.has_flag(.option) {
                    g.expr(left)
                    g.writeln('.state = 0;')
                    g.write('memcpy(')
                    g.expr(left)
                    g.write('.data, ')
                    g.expr(val)
                    g.writeln(', sizeof(${g.styp(var_type.clear_flag(.option))}));')
                } else {
                    g.write('memcpy(')
                    g.expr(left)
                    g.write(', ')
                    g.expr(val)
                    g.writeln(', sizeof(${g.styp(var_type)}));')
                }
            } else {
                arr_typ := styp.trim('*')
                old_is_assign_lhs := g.is_assign_lhs
                // For map IndexExpr LHS, keep is_assign_lhs = true so the index
                // generator emits `map_get_and_set` (which inserts missing keys)
                // instead of `map_get` (which returns a zero-default buffer).
                left_is_map_index := left is ast.IndexExpr
                    && g.table.final_sym(left.left_type).kind == .map
                g.is_assign_lhs = left_is_map_index
                left_expr := g.expr_string(left)
                if !is_fixed_array_init && assign_expr_unwraps_option_or_result(val) {
                    // val has an or-block — its code generator emits unwrap
                    // statements via go_before_last_stmt(), so we must emit
                    // memcpy() inline. Capturing val with expr_string() would
                    // slurp those statements into the memcpy() argument list.
                    g.write('memcpy(${left_expr}, ')
                    g.expr(val)
                    g.writeln(', sizeof(${arr_typ}));')
                } else {
                    mut fixed_right_expr := ''
                    if is_fixed_array_init {
                        right := val as ast.ArrayInit
                        right_var := g.new_tmp_var()
                        g.write('${arr_typ} ${right_var} = ')
                        g.expr(right)
                        g.writeln(';')
                        fixed_right_expr = right_var
                    } else {
                        fixed_right_expr = g.expr_string(val)
                    }
                    g.writeln('')
                    g.writeln('memcpy(${left_expr}, ${fixed_right_expr}, sizeof(${arr_typ}));')
                }
                g.is_assign_lhs = old_is_assign_lhs
                g.is_assign_lhs = false
            }
        } else {
            is_inside_ternary := g.inside_ternary != 0
            cur_line := if is_inside_ternary && is_decl {
                g.register_ternary_name(ident.name)
                g.empty_line = false
                g.go_before_ternary()
            } else {
                ''
            }
            if mut left is ast.IndexExpr && left.is_index_operator {
                g.write(cur_line)
                if node.op == .assign {
                    g.index_operator_call(left.left, left.left_type, left.index, left.index_type,
                        '[]=', val, val_type)
                } else {
                    infix_op := token.assign_op_to_infix_op(node.op)
                    op_expr := ast.InfixExpr{
                        left:          ast.Expr(left)
                        right:         val
                        op:            infix_op
                        pos:           node.pos
                        left_type:     left.typ
                        right_type:    val_type
                        promoted_type: g.type_resolver.promote_type(left.typ, val_type)
                    }
                    g.index_operator_call(left.left, left.left_type, left.index, left.index_type,
                        '[]=', ast.Expr(op_expr), left.typ)
                }
                if !g.inside_for_c_stmt {
                    g.writeln(';')
                }
                continue
            }
            mut str_add := false
            mut op_overloaded := false
            mut op_expected_left := ast.no_type
            mut op_expected_right := ast.no_type
            is_shared_re_assign := !is_decl && node.left_types[i].has_flag(.shared_f)
                && left is ast.Ident && left_sym.kind in [.array, .map, .struct]
            mut is_mut_arg_pointer_rebind := false
            // Keep pointer traversal assignments on auto-deref vars as local pointer rebinds,
            // but only for function arguments (is_arg), not for loop iteration variables.
            if !is_decl && !is_shared_re_assign && !var_type.has_flag(.option)
                && var_type.is_any_kind_of_pointer() && unwrapped_val_type.is_any_kind_of_pointer()
                && left.is_auto_deref_var() && !val.is_auto_deref_var() && node.op == .assign
                && left.is_auto_deref_arg() {
                is_mut_arg_pointer_rebind = true
            }
            if node.op == .plus_assign && g.is_string_type(var_type)
                && g.is_string_concat_type(val_type) {
                if g.is_autofree && !g.is_builtin_mod && !g.is_autofree_tmp
                    && (!g.is_string_type(val_type)
                    || val !in [ast.Ident, ast.StringLiteral, ast.SelectorExpr, ast.ComptimeSelector]) {
                    str_add_rhs_tmp = '_str_add_rhs_${node.pos.pos}_${i}'
                    if g.is_string_type(val_type) {
                        g.writeln(g.autofree_tmp_arg_init_stmt('string ${str_add_rhs_tmp} = ', val))
                    } else {
                        g.writeln('string ${str_add_rhs_tmp} = ${g.expr_string_with_cast(val,
                            val_type, ast.string_type)};')
                        val_type = ast.string_type
                    }
                    val = ast.Expr(ast.Ident{
                        mod:  g.cur_mod.name
                        name: str_add_rhs_tmp
                    })
                    str_add_rhs_needs_free = true
                    skip_str_add_rhs_clone = true
                    defer(fn) {
                        if str_add_rhs_needs_free {
                            g.writeln('builtin__string_free(&${str_add_rhs_tmp});')
                        }
                    }
                }
                if mut left is ast.IndexExpr {
                    if g.table.sym(left.left_type).kind == .array_fixed {
                        // strs[0] += str2 => `strs[0] = _string__plus(strs[0], str2)`
                        g.expr(left)
                        g.write(' = builtin__string__plus(')
                    } else {
                        // a[0] += str => `builtin__array_set(&a, 0, &(string[]) {_string__plus(...))})`
                        g.expr(left)
                        g.write('builtin__string__plus(')
                    }
                } else {
                    // allow literal values to auto deref var (e.g.`for mut v in values { v += 1.0 }`)
                    if left.is_auto_deref_var() {
                        g.write('*')
                    }
                    // str += str2 => `str = builtin__string__plus(str, str2)`
                    g.expr(left)
                    g.write(' = builtin__string__plus(')
                }
                g.is_assign_lhs = false
                str_add = true
            }
            // Assignment Operator Overloading
            has_power_assign_overload := node.op == .power_assign
                && left_sym.find_method_with_generic_parent('**') != none
            if (((left_sym.kind == .struct && right_sym.kind == .struct)
                || (left_sym.kind == .alias && right_sym.kind == .alias))
                && node.op in [.plus_assign, .minus_assign, .div_assign, .mult_assign, .power_assign, .mod_assign])
                || has_power_assign_overload {
                extracted_op := match node.op {
                    .plus_assign { '+' }
                    .minus_assign { '-' }
                    .div_assign { '/' }
                    .mod_assign { '%' }
                    .mult_assign { '*' }
                    .power_assign { '**' }
                    else { 'unknown op' }
                }

                pos := g.out.len
                g.expr(left)
                struct_info := g.table.final_sym(var_type)
                if left_sym.info is ast.Struct && left_sym.info.generic_types.len > 0 {
                    concrete_types := left_sym.info.concrete_types
                    mut method_name := left_sym.cname + '_' + util.replace_op(extracted_op)
                    specialized_suffix := g.generic_fn_name(concrete_types, '')
                    if specialized_suffix != '' && !method_name.ends_with(specialized_suffix) {
                        method_name = g.generic_fn_name(concrete_types, method_name)
                    }
                    g.write(' = ${method_name}(')
                    g.expr(left)
                    g.write(', ')
                    g.expr(val)
                    g.writeln(');')
                    return
                } else if left_sym.kind == .alias
                    && g.table.final_sym(g.unwrap_generic(var_type)).is_number()
                    && !left_sym.has_method(extracted_op) {
                    g.write(' = ')
                    if node.op == .power_assign {
                        g.gen_power_assign_expr(left, var_type, val, val_type)
                    } else {
                        g.expr(left)
                        g.write(' ${extracted_op} ')
                        g.expr(val)
                    }
                    if !g.inside_for_c_stmt {
                        g.write(';')
                    }
                    return
                } else if left_sym.kind == .alias && struct_info.kind == .struct
                    && struct_info.info is ast.Struct && struct_info.info.generic_types.len > 0 {
                    mut method_name := struct_info.cname + '_' + util.replace_op(extracted_op)
                    specialized_suffix := g.generic_fn_name(struct_info.info.concrete_types, '')
                    if specialized_suffix != '' && !method_name.ends_with(specialized_suffix) {
                        method_name = g.generic_fn_name(struct_info.info.concrete_types,
                            method_name)
                    }
                    g.write(' = ${method_name}(')
                    g.expr(left)
                    g.write(', ')
                    g.expr(val)
                    g.writeln(');')
                    return
                } else {
                    if g.table.final_sym(g.unwrap_generic(var_type)).kind == .array_fixed {
                        g.go_back_to(pos)
                        g.empty_line = true
                        g.write('memcpy(')
                        g.expr(left)
                        g.write(', ${styp}_${util.replace_op(extracted_op)}(')
                    } else {
                        g.write(' = ${styp}_${util.replace_op(extracted_op)}(')
                    }
                    method := g.table.find_method(left_sym, extracted_op) or {
                        // the checker will most likely have found this, already...
                        g.error('assignment operator `${extracted_op}=` used but no `${extracted_op}` method defined',
                            node.pos)
                        ast.Fn{}
                    }
                    op_expected_left = method.params[0].typ
                    op_expected_right = method.params[1].typ
                    op_overloaded = true
                }
            }
            final_left_sym := g.table.final_sym(g.unwrap_generic(var_type))
            final_right_sym := g.table.final_sym(unwrapped_val_type)
            mut aligned := 0
            is_safe_shift_assign := !g.pref.translated && !g.file.is_translated
                && node.op in [.left_shift_assign, .right_shift_assign] && final_left_sym.is_int()
            safe_shift_fn_name := if is_safe_shift_assign {
                g.safe_shift_fn_name(var_type, token.assign_op_to_infix_op(node.op))
            } else {
                ''
            }
            if final_left_sym.info is ast.Struct {
                if attr := final_left_sym.info.attrs.find_first('aligned') {
                    aligned = if attr.arg == '' { 0 } else { attr.arg.int() }
                }
            }

            if final_left_sym.kind == .bool && final_right_sym.kind == .bool
                && node.op in [.boolean_or_assign, .boolean_and_assign] {
                extracted_op := match node.op {
                    .boolean_or_assign {
                        '||'
                    }
                    .boolean_and_assign {
                        '&&'
                    }
                    else {
                        'unknown op'
                    }
                }

                g.expr(left)
                g.write(' = ')
                g.expr(left)
                g.write(' ${extracted_op} ')
                g.expr(val)
                g.writeln(';')
                return
            }
            if node.op == .power_assign && !op_overloaded {
                g.write_assign_target_expr(left, var_type)
                g.write(' = ')
                g.gen_power_assign_expr(left, var_type, val, val_type)
                g.writeln(';')
                return
            }
            if right_sym.info is ast.FnType && is_decl {
                if is_inside_ternary {
                    g.out.write_string(util.tabs(g.indent - g.inside_ternary))
                }
                fn_name := c_fn_name(g.get_ternary_name(ident.name))

                if val_type.has_flag(.option) {
                    ret_styp := g.styp(g.unwrap_generic(val_type))
                    g.write('${ret_styp} ${fn_name}')
                } else {
                    g.write_fntype_decl(fn_name, right_sym.info, var_type.nr_muls())
                }
            } else {
                if is_decl {
                    if is_inside_ternary {
                        g.out.write_string(util.tabs(g.indent - g.inside_ternary))
                    }
                    mut is_used_var_styp := false
                    if ident.name !in g.defer_vars {
                        val_sym := g.table.sym(val_type)
                        if val_sym.info is ast.Struct && val_sym.info.generic_types.len > 0 {
                            if val is ast.StructInit {
                                var_styp := g.styp(val.typ)
                                if var_type.has_flag(.shared_f) {
                                    g.write('__shared__${var_styp}* ')
                                } else {
                                    g.write('${var_styp} ')
                                }
                                is_used_var_styp = true
                            } else if val is ast.PrefixExpr {
                                if val.op == .amp && val.right is ast.StructInit {
                                    var_styp := g.styp(val.right.typ.ref())
                                    if var_type.has_flag(.shared_f) {
                                        g.write('__shared__')
                                    }
                                    g.write('${var_styp} ')
                                    is_used_var_styp = true
                                }
                            }
                        }
                        if !is_used_var_styp {
                            if !val_type.has_flag(.option) && left_sym.is_array_fixed() {
                                if left_sym.info is ast.Alias {
                                    parent_sym := g.table.final_sym(left_sym.info.parent_type)
                                    styp = g.styp(left_sym.info.parent_type)
                                    if !parent_sym.is_array_fixed_ret() {
                                        g.write('${styp} ')
                                    } else {
                                        g.write('${styp[3..]} ')
                                    }
                                } else {
                                    if !left_sym.is_array_fixed_ret() {
                                        g.write('${styp} ')
                                    } else {
                                        g.write('${styp[3..]} ')
                                    }
                                }
                            } else {
                                g.write('${styp} ')
                            }
                        }
                        if is_auto_heap && !(val_type.is_ptr() && val_type.has_flag(.option)) {
                            g.write('*')
                        }
                    }
                }
                if left in [ast.Ident, ast.SelectorExpr] && !g.is_smartcast_assign_lhs(left) {
                    g.prevent_sum_type_unwrapping_once = true
                }
                if !is_fixed_array_var || is_decl || is_shared_re_assign {
                    if op_overloaded {
                        g.op_arg(left, op_expected_left, var_type)
                    } else {
                        if !is_decl && !is_shared_re_assign
                            && (left.is_auto_deref_var() || is_auto_heap)
                            && !is_mut_arg_pointer_rebind
                            && (!var_type.has_flag(.option) || is_auto_heap) {
                            g.write('*')
                        }
                        if var_type.has_flag(.option_mut_param_t) {
                            g.expr(left)
                            g.write(' = ')
                        } else {
                            g.expr(left)
                        }
                        if !is_decl && var_type.has_flag(.shared_f) {
                            g.write('->val') // don't reset the mutex, just change the value
                        }
                    }
                }
            }
            if is_inside_ternary && is_decl {
                g.write(';\n${cur_line}')
                g.out.write_string(util.tabs(g.indent))
                g.expr(left)
            }
            if is_decl && node.is_static
                && g.gen_static_decl_runtime_init(node, left, var_type, val, val_type) {
                continue
            }
            g.is_assign_lhs = false
            left_expr := left
            if left_expr is ast.IndexExpr && g.cur_indexexpr.len > 0 {
                cur_indexexpr = g.cur_indexexpr.len - 1
            }
            if is_fixed_array_var || is_va_list {
                if is_decl {
                    g.writeln(';')
                    if is_va_list {
                        continue
                    }
                }
            } else if !var_type.has_flag(.option_mut_param_t) && cur_indexexpr == -1 && !str_add
                && !op_overloaded && !is_safe_add_assign && !is_safe_sub_assign
                && !is_safe_mul_assign && !is_safe_div_assign && !is_safe_mod_assign
                && !is_safe_shift_assign {
                g.write(' ${op} ')
            } else if (str_add || op_overloaded) && !is_safe_add_assign && !is_safe_sub_assign
                && !is_safe_mul_assign && !is_safe_div_assign && !is_safe_mod_assign {
                g.write(', ')
            } else if is_safe_shift_assign {
                g.write(' = ${safe_shift_fn_name}(')
                g.expr(left)
                g.write(', (u64)')
            } else if is_safe_add_assign || is_safe_sub_assign || is_safe_mul_assign
                || is_safe_div_assign || is_safe_mod_assign {
                overflow_styp := g.styp(get_overflow_fn_type(var_type))
                div_mod_styp :=
                    g.styp(g.unwrap_generic(var_type).clear_flag(.shared_f).clear_flag(.atomic_f))
                vsafe_fn_name := match true {
                    is_safe_add_assign { 'builtin__overflow__add_${overflow_styp}' }
                    is_safe_sub_assign { 'builtin__overflow__sub_${overflow_styp}' }
                    is_safe_mul_assign { 'builtin__overflow__mul_${overflow_styp}' }
                    is_safe_div_assign { 'VSAFE_DIV_${div_mod_styp}' }
                    is_safe_mod_assign { 'VSAFE_MOD_${div_mod_styp}' }
                    else { '' }
                }

                if is_safe_div_assign || is_safe_mod_assign {
                    g.vsafe_arithmetic_ops[vsafe_fn_name] = VSafeArithmeticOp{
                        typ: g.unwrap_generic(var_type).clear_flag(.shared_f).clear_flag(.atomic_f)
                        op:  token.assign_op_to_infix_op(node.op)
                    }
                }
                g.write(' = ${vsafe_fn_name}(')
                g.expr(left)
                g.write(',')
            }
            mut decl_tmp_var := ''
            mut decl_stmt_str := ''
            if is_decl && g.inside_ternary == 0 && !node.is_static && !var_type.has_flag(.shared_f)
                && g.decl_assign_struct_init_needs_tmp(val) {
                decl_stmt_str = g.go_before_last_stmt().trim_space()
                g.empty_line = true
                decl_tmp_var = g.new_tmp_var()
                g.write('${styp} ')
                if is_auto_heap && !(val_type.is_ptr() && val_type.has_flag(.option)) {
                    g.write('*')
                }
                g.write('${decl_tmp_var} ${op} ')
            }
            mut cloned := false
            if g.is_autofree {
                if right_sym.kind in [.array, .string] && !unwrapped_val_type.has_flag(.shared_f) {
                    if !skip_str_add_rhs_clone
                        && g.gen_clone_assignment(var_type, val, unwrapped_val_type, false) {
                        cloned = true
                    }
                } else if right_sym.info is ast.Interface && var_type != ast.error_type {
                    g.register_free_method(var_type)
                }
            }
            if !cloned {
                if g.comptime.comptime_for_field_var == ''
                    && ((var_type.has_flag(.option) && !val_type.has_flag(.option))
                    || (var_type.has_flag(.result) && !val_type.has_flag(.result))) {
                    old_inside_opt_or_res := g.inside_opt_or_res
                    defer(fn) {
                        g.inside_opt_or_res = old_inside_opt_or_res
                    }
                    g.inside_opt_or_res = true
                    if is_decl && is_auto_heap && var_type.has_flag(.option) {
                        g.write('&')
                    }
                    tmp_var := g.new_tmp_var()
                    g.expr_with_tmp_var(val, val_type, var_type, tmp_var, true)
                } else if is_fixed_array_var {
                    // TODO: Instead of the translated check, check if it's a pointer already
                    // and don't generate memcpy &
                    typ_str := g.styp(val_type).trim('*')
                    final_typ_str := if is_fixed_array_var { '' } else { '(${typ_str}*)' }
                    final_ref_str := if is_fixed_array_var {
                        ''
                    } else if val_type.is_ptr() {
                        '(byte*)'
                    } else {
                        '(byte*)&'
                    }
                    if val_type.has_flag(.option) {
                        g.expr(left)
                        g.write(' = ')
                        g.expr(val)
                    } else {
                        if op_overloaded {
                            g.expr(left)
                            g.write(', ')
                            g.expr(val)
                            g.write(').ret_arr, sizeof(${typ_str})')
                        } else {
                            g.write('memcpy(${final_typ_str}')
                            g.expr(left)
                            g.write(', ${final_ref_str}')
                            g.expr(val)
                            g.write(', sizeof(${typ_str}))')
                        }
                    }
                } else if is_decl {
                    g.is_shared = var_type.has_flag(.shared_f)
                    if is_fixed_array_init && !has_val {
                        if val is ast.ArrayInit {
                            g.array_init(val, g.ident_cname(ident))
                        } else {
                            g.write('{0}')
                        }
                    } else {
                        is_option_unwrapped := assign_expr_unwraps_option_or_result(val)
                        is_option_auto_heap := is_auto_heap && is_option_unwrapped
                        auto_heap_uses_existing_storage := is_auto_heap && !is_fn_var
                            && !is_option_auto_heap
                            && g.auto_heap_assignment_uses_existing_storage(val, val_type)
                        // For large structs (with large fixed arrays), avoid stack-allocated
                        // compound literals which can cause stack overflow. Use vcalloc directly.
                        mut is_large_struct_heap := false
                        if is_auto_heap && !is_fn_var && val is ast.StructInit
                            && g.struct_has_large_fixed_array(val.typ) {
                            is_large_struct_heap = true
                        }
                        if is_auto_heap && !is_fn_var && !is_large_struct_heap
                            && !auto_heap_uses_existing_storage {
                            if aligned != 0 {
                                g.write('HEAP_align(${styp}, (')
                            } else {
                                ptrmap_o, _ := g.vgc_ptrmap(var_type.set_nr_muls(0))
                                if ptrmap_o.len > 0 {
                                    g.write('HEAP_vgc(${styp}, (')
                                } else {
                                    g.write('HEAP(${styp}, (')
                                }
                            }
                        }
                        if !is_fn_var && val.is_auto_deref_var() && !is_option_unwrapped
                            && !g.auto_deref_source_type_is_pointer(val) {
                            g.write('*')
                        }
                        if (var_type.has_flag(.option) && val !in [ast.Ident, ast.SelectorExpr])
                            || gen_or {
                            g.expr_with_opt_or_block(val, val_type, left, var_type,
                                is_option_auto_heap)
                        } else if val is ast.ArrayInit {
                            cvar_name := g.ident_cname(ident)
                            if val.is_fixed && ident.name in g.defer_vars {
                                g.go_before_last_stmt()
                                g.empty_line = true
                                g.write('memcpy(${cvar_name}, ')
                                g.write('(${styp})')
                                g.array_init(val, cvar_name)
                                g.write(', sizeof(${styp}))')
                            } else {
                                g.array_init(val, cvar_name)
                            }
                        } else if val is ast.ParExpr && val.expr is ast.ArrayInit {
                            array_init := val.expr as ast.ArrayInit
                            cvar_name := g.ident_cname(ident)
                            if array_init.is_fixed && ident.name in g.defer_vars {
                                g.go_before_last_stmt()
                                g.empty_line = true
                                g.write('memcpy(${cvar_name}, ')
                                g.write('(${styp})')
                                g.array_init(array_init, cvar_name)
                                g.write(', sizeof(${styp}))')
                            } else {
                                g.array_init(array_init, cvar_name)
                            }
                        } else if var_type.has_flag(.shared_f) && !val_type.has_flag(.shared_f)
                            && !val_type.is_ptr() {
                            g.expr_with_cast(val, val_type, var_type)
                        } else if val_type.has_flag(.shared_f) || orig_val_shared {
                            g.expr_with_cast(val, val_type.set_flag(.shared_f), var_type)
                        } else if val in [ast.MatchExpr, ast.IfExpr]
                            && unaliased_right_sym.info is ast.ArrayFixed {
                            tmp_var := g.expr_with_var(val, var_type, false)
                            // When the temp var is a return wrapper struct (_v_Array_fixed_...),
                            // access .ret_arr to get the actual C array for subscripting.
                            init_expr := if unaliased_right_sym.info.is_fn_ret {
                                '${tmp_var}.ret_arr'
                            } else {
                                tmp_var
                            }
                            g.fixed_array_var_init(init_expr, false,
                                unaliased_right_sym.info.elem_type, unaliased_right_sym.info.size)
                        } else if is_large_struct_heap && val is ast.StructInit {
                            // For large structs, use vcalloc directly to avoid stack overflow
                            // from compound literals on the stack
                            tmp_var := g.new_tmp_var()
                            stmt_str := g.go_before_last_stmt()
                            g.empty_line = true
                            g.writeln('${styp}* ${tmp_var} = (${styp}*)builtin__vcalloc(sizeof(${styp}));')
                            // Initialize non-zero fields
                            val_sym := g.table.final_sym(val.typ)
                            if val_sym.info is ast.Struct {
                                for init_field in val.init_fields {
                                    if init_field.typ == 0 {
                                        continue
                                    }
                                    field_name := c_name(init_field.name)
                                    g.write('${tmp_var}->${field_name} = ')
                                    g.expr(init_field.expr)
                                    g.writeln(';')
                                }
                                // Handle fields with default values
                                for field in val_sym.info.fields {
                                    mut found := false
                                    for init_field in val.init_fields {
                                        if init_field.name == field.name {
                                            found = true
                                            break
                                        }
                                    }
                                    if !found && field.has_default_expr {
                                        field_name := c_name(field.name)
                                        g.write('${tmp_var}->${field_name} = ')
                                        g.expr(field.default_expr)
                                        g.writeln(';')
                                    }
                                }
                            }
                            g.empty_line = false
                            g.write2(stmt_str, tmp_var)
                        } else {
                            old_inside_assign_fn_var := g.inside_assign_fn_var
                            g.inside_assign_fn_var = val is ast.PrefixExpr && val.op == .amp
                                && is_fn_var
                            mut nval := val
                            if val is ast.PrefixExpr && val.right is ast.CallExpr {
                                call_expr := val.right as ast.CallExpr
                                if call_expr.name == 'new_array_from_c_array' {
                                    nval = call_expr
                                    if !var_type.has_flag(.shared_f) {
                                        g.write('HEAP(${g.styp(var_type.clear_ref())}, ')
                                    }
                                    g.expr(nval)
                                    if !var_type.has_flag(.shared_f) {
                                        g.write(')')
                                    }
                                }
                            }
                            if nval == val {
                                if auto_heap_uses_existing_storage {
                                    g.write_auto_heap_assignment_expr(nval, val_type)
                                } else {
                                    g.expr_in_value_context(nval, val_type, var_type)
                                }
                                if !is_fn_var && is_auto_heap && is_option_auto_heap
                                    && !is_large_struct_heap {
                                    if aligned != 0 {
                                        g.write('), ${aligned})')
                                    } else {
                                        g.write('))')
                                    }
                                }
                            }
                            g.inside_assign_fn_var = old_inside_assign_fn_var
                        }
                        if !is_fn_var && is_auto_heap && !is_option_auto_heap
                            && !auto_heap_uses_existing_storage && !is_large_struct_heap {
                            if aligned != 0 {
                                g.write('), ${aligned})')
                            } else {
                                ptrmap, nptrs := g.vgc_ptrmap(var_type.set_nr_muls(0))
                                if ptrmap.len > 0 {
                                    g.write('), ${ptrmap}, ${nptrs})')
                                } else {
                                    g.write('))')
                                }
                            }
                        }
                    }
                } else {
                    // var = &auto_heap_var
                    old_is_auto_heap := g.is_option_auto_heap
                    defer(fn) {
                        g.is_option_auto_heap = old_is_auto_heap
                    }
                    if val is ast.Ident && val.is_mut() && var_type.is_ptr() {
                        if var_type.nr_muls() < val_type.nr_muls() {
                            g.write('*'.repeat(var_type.nr_muls()))
                        }
                    }
                    g.is_option_auto_heap = val_type.has_flag(.option) && val is ast.PrefixExpr
                        && val.right is ast.Ident && (val.right as ast.Ident).is_auto_heap()
                    if var_type.has_flag(.option) || gen_or {
                        g.expr_with_opt_or_block(val, val_type, left, var_type, false)
                    } else if node.has_cross_var {
                        g.gen_cross_tmp_variable(node.left, val)
                    } else if val is ast.None {
                        if var_type.has_flag(.generic)
                            && g.unwrap_generic(var_type).has_flag(.option)
                            && var_type.nr_muls() > 0 {
                            g.gen_option_error(var_type.set_nr_muls(0), ast.None{})
                        } else {
                            g.gen_option_error(var_type, ast.None{})
                        }
                    } else {
                        if op_overloaded {
                            g.op_arg(val, op_expected_right, val_type)
                        } else {
                            exp_type := if is_mut_arg_pointer_rebind {
                                var_type
                            } else if var_type.is_ptr()
                                && (left.is_auto_deref_var() || var_type.has_flag(.shared_f)) {
                                var_type.deref()
                            } else {
                                var_type
                            }.clear_flag(.shared_f) // don't reset the mutex, just change the value
                            mut use_heap_pointed_ident := false
                            mut use_raw_auto_heap_ident := false
                            if val is ast.PrefixExpr && val.op == .amp && val.right is ast.Ident {
                                right_ident := val.right as ast.Ident
                                mut resolved_right_type := g.resolved_expr_type(ast.Expr(right_ident),
                                    val.right_type)
                                if resolved_right_type == 0 {
                                    resolved_right_type = val.right_type
                                }
                                resolved_right_type =
                                    g.unwrap_generic(g.recheck_concrete_type(resolved_right_type))
                                rhs_sym_ := g.table.final_sym(resolved_right_type)
                                if rhs_sym_.kind != .function {
                                    right_type_for_compare :=
                                        resolved_right_type.clear_flag(.shared_f).clear_flag(.atomic_f)
                                    exp_type_for_compare :=
                                        exp_type.clear_flag(.shared_f).clear_flag(.atomic_f)
                                    right_points_to_heap := resolved_right_type.is_ptr()
                                        && g.table.final_sym(resolved_right_type.deref()).is_heap()
                                    use_heap_pointed_ident = resolved_right_type != 0
                                        && right_points_to_heap
                                        && right_type_for_compare == exp_type_for_compare
                                    right_is_auto_heap := right_ident.is_auto_heap()
                                        || g.resolved_ident_is_auto_heap(right_ident)
                                    use_raw_auto_heap_ident = exp_type.is_ptr()
                                        && right_is_auto_heap && !use_heap_pointed_ident
                                        && resolved_right_type != 0 && !resolved_right_type.is_ptr()
                                }
                            }
                            if use_heap_pointed_ident {
                                g.expr(ast.Expr((val as ast.PrefixExpr).right))
                            } else if use_raw_auto_heap_ident {
                                old_inside_assign_fn_var := g.inside_assign_fn_var
                                g.inside_assign_fn_var = true
                                g.expr(ast.Expr((val as ast.PrefixExpr).right))
                                g.inside_assign_fn_var = old_inside_assign_fn_var
                            } else {
                                g.expr_with_cast(val, val_type, exp_type)
                            }
                        }
                    }
                }
            }
            if str_add || op_overloaded || is_safe_add_assign || is_safe_sub_assign
                || is_safe_mul_assign || is_safe_div_assign || is_safe_mod_assign {
                g.write(')')
            } else if is_safe_shift_assign {
                g.write(')')
            }
            if node_.op == .assign && var_type.has_flag(.option_mut_param_t) {
                g.write('.data, sizeof(${g.base_type(val_type)}))')
            }
            if cur_indexexpr != -1 {
                g.cur_indexexpr.delete(cur_indexexpr)
                g.write(' })')
                g.is_arraymap_set = g.cur_indexexpr.len > 0
            }
            if decl_tmp_var != '' {
                g.writeln(';')
                g.write2(decl_stmt_str, ' ')
                g.write(decl_tmp_var)
            }
            g.is_shared = false
        }
        g.right_is_opt = false
        if g.inside_ternary == 0 && (node.left.len > 1 || !node.is_simple) {
            g.writeln(';')
        }
    }
}

fn (mut g Gen) gen_multi_return_assign(node &ast.AssignStmt, return_type ast.Type, return_sym ast.TypeSymbol) {
    // multi return
    // TODO: Handle in if_expr
    mut ret_type := return_type
    mut ret_sym := return_sym
    mut suffix := ''
    if g.comptime.inside_comptime_for && node.right[0] is ast.CallExpr {
        call_expr := node.right[0] as ast.CallExpr
        if call_expr.concrete_types.len > 0 && return_sym.info is ast.MultiReturn
            && g.comptime.comptime_for_field_var != '' {
            field_type := g.comptime.comptime_for_field_type
            field_sym := g.table.sym(field_type)
            if field_sym.info is ast.Map {
                map_info := field_sym.info as ast.Map
                ret_type =
                    g.table.find_or_register_multi_return([map_info.key_type, map_info.value_type])
                ret_sym = *g.table.sym(ret_type)
            }
        }
        if g.comptime.comptime_for_field_var != '' {
            suffix = '_${g.comptime.comptime_for_field_value.name}'
        }
    }
    if node.right[0] is ast.CallExpr {
        call_expr := node.right[0] as ast.CallExpr
        mut fn_var_type := ast.void_type
        lookup_name := if call_expr.left is ast.Ident {
            call_expr.left.name
        } else {
            call_expr.name
        }
        resolved_current_type := g.resolve_current_fn_generic_param_type(lookup_name)
        if resolved_current_type != 0
            && g.table.final_sym(g.unwrap_generic(resolved_current_type)).kind == .function {
            fn_var_type = g.unwrap_generic(g.recheck_concrete_type(resolved_current_type))
        } else if call_expr.is_fn_var {
            fn_var_type = g.unwrap_generic(g.recheck_concrete_type(call_expr.fn_var_type))
        }
        if fn_var_type == 0 {
            if obj := call_expr.scope.find_var(lookup_name) {
                if g.table.final_sym(g.unwrap_generic(obj.typ)).kind == .function {
                    fn_var_type = g.unwrap_generic(g.recheck_concrete_type(obj.typ))
                }
            }
        }
        if fn_var_type != 0 {
            fn_sym := g.table.final_sym(fn_var_type)
            if fn_sym.info is ast.FnType {
                resolved_ret_type :=
                    g.unwrap_generic(g.recheck_concrete_type(fn_sym.info.func.return_type))
                if resolved_ret_type != 0 && g.table.sym(resolved_ret_type).kind == .multi_return {
                    ret_type = resolved_ret_type
                    ret_sym = *g.table.sym(ret_type)
                }
            }
        }
    }
    mr_var_name := 'mr_${node.pos.pos}${suffix}'
    mut is_option := ret_type.has_flag(.option)
    mut mr_styp := g.styp(ret_type.clear_flag(.result))
    if node.right[0] is ast.CallExpr && node.right[0].or_block.kind != .absent {
        is_option = false
        mr_styp = g.styp(ret_type.clear_option_and_result())
    }
    g.write('${mr_styp} ${mr_var_name} = ')
    g.expr(node.right[0])
    g.writeln(';')
    raw_mr_types := (ret_sym.info as ast.MultiReturn).types
    is_generic_context := g.cur_fn != unsafe { nil } && g.cur_concrete_types.len > 0
    mr_types := if is_generic_context {
        raw_mr_types.map(g.unwrap_generic(g.recheck_concrete_type(it)))
    } else if node.right_types.len == raw_mr_types.len {
        node.right_types.clone()
    } else {
        raw_mr_types.clone()
    }
    mut recompute_types := node.op == .decl_assign || ret_type != return_type
    if g.comptime.inside_comptime_for && node.right[0] is ast.CallExpr {
        call_expr := node.right[0] as ast.CallExpr
        if call_expr.concrete_types.len > 0 && g.comptime.comptime_for_field_var != ''
            && return_sym.info is ast.MultiReturn {
            recompute_types = true
            for i, mut lx in &node.left {
                if mut lx is ast.Ident && lx.kind != .blank_ident {
                    if mut lx.obj is ast.Var {
                        lx.obj.typ = mr_types[i]
                    }
                }
            }
        }
    }
    if recompute_types {
        for i, mut lx in &node.left {
            if mut lx is ast.Ident && lx.kind != .blank_ident {
                if mut lx.obj is ast.Var && i < mr_types.len {
                    lx.obj.typ = mr_types[i]
                    if !mr_types[i].has_option_or_result() {
                        lx.obj.orig_type = ast.no_type
                        lx.obj.smartcasts = []
                        lx.obj.is_unwrapped = false
                    }
                    if lx.obj.ct_type_var != .no_comptime {
                        g.type_resolver.update_ct_type(lx.name, mr_types[i])
                    }
                }
                if i < mr_types.len && lx.scope != unsafe { nil } {
                    if mut scope_var := lx.scope.find_var(lx.name) {
                        scope_var.typ = mr_types[i]
                        if !mr_types[i].has_option_or_result() {
                            scope_var.orig_type = ast.no_type
                            scope_var.smartcasts = []
                            scope_var.is_unwrapped = false
                        }
                    }
                }
            }
        }
    }
    for i, lx in node.left {
        mut cur_indexexpr := -1
        mut is_auto_heap := false
        mut ident := ast.Ident{
            scope: unsafe { nil }
        }
        if lx is ast.Ident {
            ident = lx
            if lx.kind == .blank_ident {
                continue
            }
            if lx.obj is ast.Var {
                is_auto_heap = lx.obj.is_auto_heap
            }
        }
        if lx is ast.IndexExpr && g.cur_indexexpr.len > 0 {
            cur_indexexpr = g.cur_indexexpr.index(lx.pos.pos)
        }
        left_type := if recompute_types { mr_types[i] } else { node.left_types[i] }
        styp := if ident.name in g.defer_vars { '' } else { g.styp(left_type) }
        needs_auto_heap_alloc := is_auto_heap && node.op == .decl_assign
        if node.op == .decl_assign {
            g.write('${styp} ')
        }
        if lx.is_auto_deref_var() {
            g.write('*')
        }
        noscan := if is_auto_heap { g.check_noscan(return_type) } else { '' }
        mut aligned := 0
        sym := g.table.final_sym(left_type)
        if sym.info is ast.Struct {
            if attr := sym.info.attrs.find_first('aligned') {
                aligned = if attr.arg == '' { 0 } else { attr.arg.int() }
            }
        }
        if left_type.has_flag(.option) {
            base_typ := g.base_type(left_type)
            tmp_var := if needs_auto_heap_alloc {
                if aligned != 0 {
                    'HEAP_align(${styp}, ${mr_var_name}.arg${i}, ${aligned})'
                } else {
                    'HEAP${noscan}(${styp}, ${mr_var_name}.arg${i})'
                }
            } else if is_option {
                '(*((${g.base_type(return_type)}*)${mr_var_name}.data)).arg${i}'
            } else {
                '${mr_var_name}.arg${i}'
            }
            if mr_types[i].has_flag(.option) {
                old_left_is_opt := g.left_is_opt
                g.left_is_opt = true
                g.expr(lx)
                g.writeln(' = ${tmp_var};')
                g.left_is_opt = old_left_is_opt
            } else {
                g.write('builtin___option_ok(&(${base_typ}[]) { ${tmp_var} }, (${option_name}*)(&')
                tmp_left_is_opt := g.left_is_opt
                g.left_is_opt = true
                g.expr(lx)
                g.left_is_opt = tmp_left_is_opt
                g.writeln('), sizeof(${base_typ}));')
            }
        } else {
            g.expr(lx)
            if sym.kind == .array_fixed {
                g.writeln2(';',
                    'memcpy(&${g.expr_string(lx)}, &${mr_var_name}.arg${i}, sizeof(${styp}));')
            } else {
                if cur_indexexpr != -1 {
                    if needs_auto_heap_alloc {
                        if aligned != 0 {
                            g.writeln('HEAP_align(${styp}, ${mr_var_name}.arg${i}, ${aligned}) });')
                        } else {
                            g.writeln('HEAP${noscan}(${styp}, ${mr_var_name}.arg${i}) });')
                        }
                    } else if is_option {
                        g.writeln('(*((${g.base_type(return_type)}*)${mr_var_name}.data)).arg${i} });')
                    } else {
                        g.writeln('${mr_var_name}.arg${i} });')
                    }
                    g.cur_indexexpr.delete(cur_indexexpr)
                } else {
                    if needs_auto_heap_alloc {
                        if aligned != 0 {
                            g.writeln(' = HEAP_align(${styp}, ${mr_var_name}.arg${i}, ${aligned});')
                        } else {
                            g.writeln(' = HEAP${noscan}(${styp}, ${mr_var_name}.arg${i});')
                        }
                    } else if is_option {
                        g.writeln(' = (*((${g.base_type(return_type)}*)${mr_var_name}.data)).arg${i};')
                    } else {
                        g.writeln(' = ${mr_var_name}.arg${i};')
                    }
                }
            }
        }
    }
    if g.is_arraymap_set {
        g.is_arraymap_set = false
    }
}

fn (mut g Gen) gen_cross_var_assign(node &ast.AssignStmt) {
    for i, left in node.left {
        left_is_auto_deref_var := left.is_auto_deref_var()
        match left {
            ast.Ident {
                left_typ := node.left_types[i]
                left_sym := g.table.sym(left_typ)
                mut anon_ctx := ''
                if g.anon_fn != unsafe { nil } {
                    if obj := left.scope.find_var(left.name) {
                        if obj.is_inherited {
                            anon_ctx = '${closure_ctx}->'
                        }
                    }
                }
                if left_sym.info is ast.FnType {
                    g.write_fn_ptr_decl(&left_sym.info, '_var_${left.pos.pos}')
                    g.writeln(' = ${anon_ctx}${g.ident_cname(left)};')
                } else if left_is_auto_deref_var {
                    styp := g.styp(left_typ).trim('*')
                    if left_sym.kind == .array {
                        g.writeln('${styp} _var_${left.pos.pos} = builtin__array_clone(${anon_ctx}${g.ident_cname(left)});')
                    } else {
                        g.writeln('${styp} _var_${left.pos.pos} = *${anon_ctx}${g.ident_cname(left)};')
                    }
                } else {
                    styp := g.styp(left_typ)
                    if left_sym.kind == .array {
                        g.writeln('${styp} _var_${left.pos.pos} = builtin__array_clone(&${anon_ctx}${g.ident_cname(left)});')
                    } else {
                        g.writeln('${styp} _var_${left.pos.pos} = ${anon_ctx}${g.ident_cname(left)};')
                    }
                }
            }
            ast.IndexExpr {
                if left.is_index_operator {
                    styp := g.styp(node.left_types[i])
                    g.write('${styp} _var_${left.pos.pos} = ')
                    g.expr(ast.Expr(left))
                    g.writeln(';')
                    continue
                }
                mut container_type := left.left_type
                if g.cur_fn != unsafe { nil } && g.cur_concrete_types.len > 0 {
                    resolved_container_type := g.resolved_expr_type(left.left, left.left_type)
                    if resolved_container_type != 0 {
                        container_type =
                            g.unwrap_generic(g.recheck_concrete_type(resolved_container_type))
                    }
                }
                sym := g.table.sym(g.table.unaliased_type(container_type))
                if sym.kind == .array {
                    info := sym.info as ast.Array
                    elem_sym := g.table.sym(info.elem_type)
                    needs_clone := info.elem_type == ast.string_type && g.is_autofree

                    if elem_sym.kind == .function {
                        left_typ := node.left_types[i]
                        left_sym := g.table.sym(left_typ)
                        g.write_fn_ptr_decl(left_sym.info as ast.FnType, '_var_${left.pos.pos}')
                        g.write(' = *(voidptr*)builtin__array_get(')
                    } else {
                        styp := g.styp(info.elem_type)
                        string_clone := if needs_clone { 'builtin__string_clone(' } else { '' }

                        g.write('${styp} _var_${left.pos.pos} = ${string_clone}*(${styp}*)builtin__array_get(')
                    }

                    if left.left_type.is_ptr() || left.left.is_auto_deref_var() {
                        g.write('*')
                    }
                    g.expr(left.left)
                    g.write(', ')
                    g.expr(left.index)
                    if needs_clone {
                        g.write(')')
                    }
                    g.writeln(');')
                } else if sym.kind == .array_fixed {
                    info := sym.info as ast.ArrayFixed
                    elem_sym := g.table.sym(info.elem_type)
                    if elem_sym.kind == .function {
                        left_typ := node.left_types[i]
                        left_sym := g.table.sym(left_typ)
                        g.write_fn_ptr_decl(left_sym.info as ast.FnType, '_var_${left.pos.pos}')
                        g.write(' = *(voidptr*)')
                    } else {
                        styp := g.styp(info.elem_type)
                        g.write('${styp} _var_${left.pos.pos} = ')
                    }
                    if left.left_type.is_ptr() {
                        g.write('*')
                    }
                    needs_clone := info.elem_type == ast.string_type && g.is_autofree
                    if needs_clone {
                        g.write('builtin__string_clone(')
                    }
                    g.expr(left)
                    if needs_clone {
                        g.write(')')
                    }
                    g.writeln(';')
                } else if sym.kind == .map {
                    info := sym.info as ast.Map
                    styp := g.styp(info.value_type)
                    zero := g.type_default(info.value_type)
                    val_sym := g.table.sym(info.value_type)
                    if val_sym.kind == .function {
                        left_type := node.left_types[i]
                        left_sym := g.table.sym(left_type)
                        g.write_fn_ptr_decl(left_sym.info as ast.FnType, '_var_${left.pos.pos}')
                        g.write(' = *(voidptr*)builtin__map_get(')
                    } else {
                        g.write('${styp} _var_${left.pos.pos} = *(${styp}*)builtin__map_get(')
                    }
                    if !left.left_type.is_ptr() {
                        g.write('ADDR(map, ')
                        g.expr(left.left)
                        g.write(')')
                    } else {
                        g.expr(left.left)
                    }
                    g.write(', ')
                    g.write_map_key_arg(left.index, info.key_type)
                    if val_sym.kind == .function {
                        g.writeln(', &(voidptr[]){ ${zero} });')
                    } else {
                        g.writeln(', &(${styp}[]){ ${zero} });')
                    }
                }
            }
            ast.SelectorExpr {
                styp := g.styp(left.typ)
                g.write('${styp} _var_${left.pos.pos} = ')
                g.expr(left.expr)
                sel := g.dot_or_ptr(left.expr_type)
                g.writeln('${sel}${left.field_name};')
            }
            else {}
        }
    }
}

fn (mut g Gen) gen_cross_tmp_variable(left []ast.Expr, val ast.Expr) {
    val_ := val
    match val {
        ast.Ident {
            mut has_var := false
            for lx in left {
                if lx is ast.Ident {
                    if val.name == lx.name {
                        g.write2('_var_', lx.pos.pos.str())
                        has_var = true
                        break
                    }
                }
            }
            if !has_var {
                g.expr(val_)
            }
        }
        ast.IndexExpr {
            mut has_var := false
            for lx in left {
                if val_.str() == lx.str() {
                    g.write2('_var_', lx.pos().pos.str())
                    has_var = true
                    break
                }
            }
            if !has_var {
                g.expr(val_)
            }
        }
        ast.InfixExpr {
            sym := g.table.sym(val.left_type)
            svalop := val.op.str()
            if _ := g.table.find_method(sym, svalop) {
                left_styp := g.styp(val.left_type.set_nr_muls(0))
                g.write2(left_styp, '_')
                g.write2(util.replace_op(svalop), '(')
                g.gen_cross_tmp_variable(left, val.left)
                g.write(', ')
                g.gen_cross_tmp_variable(left, val.right)
                g.write(')')
            } else {
                g.gen_cross_tmp_variable(left, val.left)
                g.write(svalop)
                g.gen_cross_tmp_variable(left, val.right)
            }
        }
        ast.ParExpr {
            g.write('(')
            g.gen_cross_tmp_variable(left, val.expr)
            g.write(')')
        }
        ast.CallExpr {
            if val.is_method {
                unwrapped_rec_type, typ_sym := g.unwrap_receiver_type(val)
                left_type := g.unwrap_generic(val.left_type)
                left_sym := g.table.sym(left_type)
                final_left_sym := g.table.final_sym(left_type)
                rec_typ_name := g.resolve_receiver_name(val, unwrapped_rec_type, final_left_sym,
                    left_sym, typ_sym)
                mut fn_name := util.no_dots('${rec_typ_name}_${val.name}')
                if resolved_sym := g.table.find_sym(rec_typ_name) {
                    if resolved_sym.is_builtin() && !fn_name.starts_with('builtin__') {
                        fn_name = 'builtin__${fn_name}'
                    }
                } else if rec_typ_name in ['int_literal', 'float_literal', 'vint_t'] {
                    fn_name = 'builtin__${fn_name}'
                }
                g.write('${fn_name}(&')
                g.gen_cross_tmp_variable(left, val.left)
                for i, arg in val.args {
                    g.gen_cross_tmp_variable(left, arg.expr)
                    if i != val.args.len - 1 {
                        g.write(', ')
                    }
                }
                g.write(')')
            } else {
                mut fn_name := val.name.replace('.', '__')
                if val.concrete_types.len > 0 {
                    fn_name = g.generic_fn_name(val.concrete_types, fn_name)
                }
                g.write('${fn_name}(')
                for i, arg in val.args {
                    g.gen_cross_tmp_variable(left, arg.expr)
                    if i != val.args.len - 1 {
                        g.write(', ')
                    }
                }
                g.write(')')
            }
        }
        ast.PrefixExpr {
            g.write(val.op.str())
            g.gen_cross_tmp_variable(left, val.right)
        }
        ast.PostfixExpr {
            g.gen_cross_tmp_variable(left, val.expr)
            g.write(val.op.str())
        }
        ast.SelectorExpr {
            mut has_var := false
            for lx in left {
                if val_.str() == lx.str() {
                    g.write2('_var_', lx.pos().pos.str())
                    has_var = true
                    break
                }
            }
            if !has_var {
                g.expr(val_)
            }
        }
        else {
            g.expr(val_)
        }
    }
}