// 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

struct IndexOperatorMethodInfo {
    method        ast.Fn
    name          string
    receiver_type ast.Type
}

enum CWideIndexKind {
    plain
    signed_64
    unsigned_64
}

fn (mut g Gen) c_wide_index_kind(index_type ast.Type) CWideIndexKind {
    if g.pref.backend != .c || index_type == 0 {
        return .plain
    }
    mut internal_index_type := g.table.unaliased_type(index_type.clear_flag(.variadic))
    internal_index_sym := g.table.final_sym(internal_index_type)
    if internal_index_sym.kind == .enum {
        internal_index_type = internal_index_sym.enum_info().typ
    }
    if internal_index_type == ast.int_literal_type || !internal_index_type.is_int() {
        return .plain
    }
    int_size, _ := g.table.type_size(ast.int_type_idx)
    internal_index_size, _ := g.table.type_size(internal_index_type.idx_type())
    if internal_index_type.is_signed() {
        return if internal_index_size <= int_size { .plain } else { .signed_64 }
    }
    return if internal_index_size < int_size { .plain } else { .unsigned_64 }
}

fn (mut g Gen) write_c_range_bound(expr ast.Expr) {
    bound_type := g.resolved_expr_type(expr, 0)
    match g.c_wide_index_kind(bound_type) {
        .signed_64 {
            g.write('builtin__v_slice_index_i64(')
            g.expr(expr)
            g.write(')')
        }
        .unsigned_64 {
            g.write('builtin__v_slice_index_u64(')
            g.expr(expr)
            g.write(')')
        }
        else {
            g.expr(expr)
        }
    }
}

fn (mut g Gen) resolved_index_operator_receiver_type(receiver ast.Expr, receiver_type ast.Type) ast.Type {
    mut resolved_type := g.recheck_concrete_type(g.resolved_expr_type(receiver, receiver_type))
    if resolved_type == 0 {
        resolved_type = receiver_type
    }
    if resolved_type == 0 || resolved_type.has_flag(.generic)
        || g.type_has_unresolved_generic_parts(resolved_type) {
        resolved_type = g.resolved_expr_type(receiver, receiver_type)
    }
    if resolved_type == 0 {
        resolved_type = receiver_type
    }
    return g.unwrap_generic(g.recheck_concrete_type(resolved_type))
}

fn (mut g Gen) index_operator_method_info(receiver ast.Expr, receiver_type ast.Type, op string) ?IndexOperatorMethodInfo {
    resolved_receiver_type := g.resolved_index_operator_receiver_type(receiver, receiver_type)
    recv :=
        g.unwrap(if resolved_receiver_type != 0 { resolved_receiver_type } else { receiver_type })
    mut method := ast.Fn{}
    mut method_name := ''
    if recv.sym.has_method(op) || recv.sym.has_method_with_generic_parent(op) {
        method = recv.sym.find_method_with_generic_parent(op) or {
            recv.sym.find_method(op) or { return none }
        }
        method_name = recv.sym.cname + '_' + util.replace_op(op)
        if recv.sym.is_builtin() {
            method_name = 'builtin__${method_name}'
        }
    } else if recv.unaliased_sym.has_method_with_generic_parent(op) {
        method = recv.unaliased_sym.find_method_with_generic_parent(op) or { return none }
        method_name = recv.unaliased_sym.cname + '_' + util.replace_op(op)
        if recv.unaliased_sym.is_builtin() {
            method_name = 'builtin__${method_name}'
        }
    } else {
        return none
    }
    method_name = g.specialized_method_name_from_receiver(method, recv.typ, method_name)
    return IndexOperatorMethodInfo{
        method:        method
        name:          method_name
        receiver_type: recv.typ
    }
}

fn (mut g Gen) index_operator_call(receiver ast.Expr, receiver_type ast.Type, index ast.Expr, index_type ast.Type, op string, value ast.Expr, value_type ast.Type) {
    info := g.index_operator_method_info(receiver, receiver_type, op) or {
        g.error('missing `${op}` overload for `${g.table.type_to_str(receiver_type)}`',
            receiver.pos())
        return
    }
    g.write(info.name)
    g.write('(')
    g.op_arg(receiver, info.method.params[0].typ, info.receiver_type)
    g.write(', ')
    g.op_arg(index, info.method.params[1].typ, index_type)
    if op == '[]=' {
        g.write(', ')
        g.op_arg(value, info.method.params[2].typ, value_type)
    }
    g.write(')')
}

fn (mut g Gen) index_expr(node ast.IndexExpr) {
    if node.index is ast.RangeExpr {
        g.index_range_expr(node, node.index)
    } else {
        if node.is_index_operator {
            g.index_operator_call(node.left, node.left_type, node.index, node.index_type, '[]',
                ast.empty_expr, ast.void_type)
            return
        }
        mut left_type := ast.Type(0)
        if node.left is ast.Ident {
            resolved_current_type := g.resolve_current_fn_generic_param_type(node.left.name)
            if resolved_current_type != 0 {
                left_type = g.unwrap_generic(g.recheck_concrete_type(resolved_current_type))
            }
        }
        if left_type == 0 {
            left_type = g.unwrap_generic(g.recheck_concrete_type(node.left_type))
        }
        if left_type == 0 || left_type.has_flag(.generic)
            || g.type_has_unresolved_generic_parts(left_type) {
            left_type = g.unwrap_generic(g.recheck_concrete_type(g.resolved_expr_type(node.left,
                node.left_type)))
        }
        if left_type == 0 {
            left_type = g.unwrap_generic(g.type_resolver.get_type_or_default(node.left,
                node.left_type))
        }
        sym := g.table.final_sym(left_type)
        if sym.kind == .array {
            g.index_of_array(node, sym)
        } else if sym.kind == .array_fixed {
            g.index_of_fixed_array(node, sym)
        } else if sym.kind == .map {
            g.index_of_map(node, sym)
        } else if sym.kind == .string && !node.left_type.is_ptr() {
            gen_or := node.or_expr.kind != .absent || node.is_option
            wide_index_kind := g.c_wide_index_kind(node.index_type)
            string_at_fn := if node.is_gated {
                'builtin__string_at_ni'
            } else {
                match wide_index_kind {
                    .signed_64 { 'builtin__string_at_i64' }
                    .unsigned_64 { 'builtin__string_at_u64' }
                    else { 'builtin__string_at' }
                }
            }
            string_at_with_check_fn := if node.is_gated {
                'builtin__string_at_with_check_ni'
            } else {
                match wide_index_kind {
                    .signed_64 { 'builtin__string_at_with_check_i64' }
                    .unsigned_64 { 'builtin__string_at_with_check_u64' }
                    else { 'builtin__string_at_with_check' }
                }
            }
            if gen_or {
                tmp_opt := g.new_tmp_var()
                cur_line := g.go_before_last_stmt()
                g.out.write_string(util.tabs(g.indent))
                opt_elem_type := g.styp(ast.u8_type.set_flag(.option))
                g.write('${opt_elem_type} ${tmp_opt} = ${string_at_with_check_fn}(')
                g.expr(ast.Expr(node.left))
                g.write(', ')
                g.expr(node.index)
                g.writeln(');')
                if !node.is_option {
                    g.or_block(tmp_opt, node.or_expr, ast.u8_type)
                }
                g.write('\n${cur_line}*(byte*)&${tmp_opt}.data')
            } else {
                is_direct_array_access := !node.is_gated && wide_index_kind == .plain
                    && (g.is_direct_array_access || node.is_direct)
                if is_direct_array_access {
                    g.expr(ast.Expr(node.left))
                    g.write('.str[ ')
                    g.expr(node.index)
                    g.write(']')
                } else {
                    g.write('${string_at_fn}(')
                    g.expr(ast.Expr(node.left))
                    g.write(', ')
                    g.expr(node.index)
                    g.write(')')
                }
            }
        } else if sym.info is ast.Aggregate
            && sym.info.types.all(g.table.type_kind(it) in [.array, .array_fixed, .string, .map]) {
            // treating sumtype of array types
            unwrapped_got_type := sym.info.types[g.aggregate_type_idx]
            g.index_expr(ast.IndexExpr{ ...node, left_type: unwrapped_got_type })
        } else {
            g.expr(ast.Expr(node.left))
            g.write('[')
            g.expr(node.index)
            g.write(']')
        }
    }
}

fn (mut g Gen) index_range_expr(node ast.IndexExpr, range ast.RangeExpr) {
    mut resolved_left_type := ast.Type(0)
    if node.left is ast.Ident {
        resolved_current_type := g.resolve_current_fn_generic_param_type(node.left.name)
        if resolved_current_type != 0 {
            resolved_left_type = resolved_current_type
        }
    }
    if resolved_left_type == 0 {
        resolved_left_type = g.recheck_concrete_type(node.left_type)
    }
    if resolved_left_type == 0 || resolved_left_type.has_flag(.generic)
        || g.type_has_unresolved_generic_parts(resolved_left_type) {
        resolved_left_type = g.resolved_expr_type(node.left, node.left_type)
    }
    if resolved_left_type == 0 {
        resolved_left_type = g.type_resolver.get_type_or_default(node.left, node.left_type)
    }
    unwrapped_left_type := g.unwrap_generic(g.recheck_concrete_type(resolved_left_type))
    sym := g.table.final_sym(unwrapped_left_type)
    mut tmp_opt := ''
    mut cur_line := ''
    mut gen_or := node.or_expr.kind != .absent || node.is_option
    left_is_shared := resolved_left_type.has_flag(.shared_f)
    if sym.kind == .string {
        if node.is_gated {
            g.write('builtin__string_substr_ni(')
        } else {
            if gen_or {
                tmp_opt = g.new_tmp_var()
                cur_line = g.go_before_last_stmt()
                g.out.write_string(util.tabs(g.indent))
                opt_elem_type := g.styp(ast.string_type.set_flag(.result))
                g.write('${opt_elem_type} ${tmp_opt} = builtin__string_substr_with_check(')
            } else {
                g.write('builtin__string_substr(')
            }
        }
        if resolved_left_type.is_ptr() {
            g.write('*')
        }
        g.expr(ast.Expr(node.left))
    } else if sym.kind == .array {
        if node.is_gated {
            g.write('builtin__array_slice_ni(')
        } else {
            g.write('builtin__array_slice(')
        }
        if left_is_shared {
            g.write('(')
        }
        if resolved_left_type.is_ptr() {
            g.write('*')
        }
        g.expr(ast.Expr(node.left))
        if left_is_shared {
            g.write(').val')
        }
    } else if sym.info is ast.ArrayFixed {
        // Convert a fixed array to V array when doing `fixed_arr[start..end]`
        noscan := g.check_noscan(sym.info.elem_type)
        if node.is_gated {
            g.write('builtin__array_slice_ni(')
        } else {
            g.write('builtin__array_slice(')
        }
        g.write('builtin__new_array_from_c_array${noscan}(')
        ctype := g.styp(sym.info.elem_type)
        g.write('${sym.info.size}, ${sym.info.size}, sizeof(${ctype}), ')
        if left_is_shared {
            g.write('(')
        }
        if resolved_left_type.is_ptr() {
            g.write('*')
        }
        if node.left is ast.ArrayInit {
            var := g.new_tmp_var()
            line := g.go_before_last_stmt().trim_space()
            styp := g.styp(node.left_type)
            g.empty_line = true
            g.write('${styp} ${var} = ')
            g.expr(ast.Expr(node.left))
            g.writeln(';')
            g.write2(line, ' ${var}')
        } else {
            g.expr(ast.Expr(node.left))
        }
        if left_is_shared {
            g.write(').val')
        }
        g.write(')')
    } else {
        g.expr(ast.Expr(node.left))
    }
    g.write(', ')
    if range.has_low {
        g.write_c_range_bound(range.low)
    } else {
        g.write('0')
    }
    g.write(', ')
    if range.has_high {
        g.write_c_range_bound(range.high)
    } else if sym.info is ast.ArrayFixed {
        g.write('${sym.info.size}')
    } else {
        g.write('${max_int}')
    }
    g.write(')')

    if gen_or {
        if !node.is_option {
            g.or_block(tmp_opt, node.or_expr, ast.string_type.set_flag(.result))
        }

        g.write('\n${cur_line}*(string*)&${tmp_opt}.data')
    }
}

fn (mut g Gen) index_of_array(node ast.IndexExpr, sym ast.TypeSymbol) {
    gen_or := node.or_expr.kind != .absent || node.is_option
    resolved_left_type := g.recheck_concrete_type(g.resolved_expr_type(node.left, node.left_type))
    left_type := if resolved_left_type != 0 { resolved_left_type } else { node.left_type }
    left_sym := if left_type != 0 {
        g.table.final_sym(g.unwrap_generic(left_type))
    } else {
        g.table.final_sym(g.unwrap_generic(node.left_type))
    }
    array_left_type := if left_sym.kind == .array { left_type } else { node.left_type }
    info := if left_sym.kind == .array {
        left_sym.info as ast.Array
    } else {
        sym.info as ast.Array
    }
    resolved_elem_type_ := g.recheck_concrete_type(g.resolved_expr_type(node, node.typ))
    resolved_elem_type := if resolved_elem_type_ == ast.int_literal_type {
        ast.int_type
    } else if resolved_elem_type_ == ast.float_literal_type {
        ast.f64_type
    } else {
        resolved_elem_type_
    }
    elem_type := if resolved_elem_type != 0 && resolved_elem_type != ast.void_type {
        resolved_elem_type
    } else if info.elem_type == ast.int_literal_type {
        ast.int_type
    } else if info.elem_type == ast.float_literal_type {
        ast.f64_type
    } else {
        info.elem_type
    }
    elem_sym := g.table.final_sym(elem_type)
    mut left_is_ptr := array_left_type.is_ptr() || node.left.is_auto_deref_var()
    // Auto-heap idents are pointers in C. `g.expr` writes `(*(name))` to deref them,
    // but suppresses that deref when the ident is on an assign LHS / inside a selector
    // LHS / inside an assign-fn-var context. In those cases the C result of `g.expr`
    // is a pointer, so this IndexExpr must emit its own `*` before `array_get`.
    if !left_is_ptr && node.left is ast.Ident && g.resolved_ident_is_auto_heap(node.left)
        && (g.is_assign_lhs || g.inside_selector_lhs || g.inside_assign_fn_var) {
        left_is_ptr = true
    }
    result_type := match true {
        gen_or && elem_type.has_flag(.option) {
            node.typ.clear_flag(.option)
        }
        gen_or {
            node.typ
        }
        else {
            elem_type
        }
    }

    result_sym := g.table.final_sym(result_type)
    elem_type_str := if elem_sym.kind == .function { 'voidptr' } else { g.styp(elem_type) }
    result_type_str := if result_sym.kind == .function { 'voidptr' } else { g.styp(result_type) }
    left_is_shared := array_left_type.has_flag(.shared_f)
    wide_index_kind := g.c_wide_index_kind(node.index_type)
    array_get_fn := if node.is_gated {
        'builtin__array_get_ni'
    } else {
        match wide_index_kind {
            .signed_64 { 'builtin__array_get_i64' }
            .unsigned_64 { 'builtin__array_get_u64' }
            else { 'builtin__array_get' }
        }
    }
    array_get_with_check_fn := if node.is_gated {
        'builtin__array_get_with_check_ni'
    } else {
        match wide_index_kind {
            .signed_64 { 'builtin__array_get_with_check_i64' }
            .unsigned_64 { 'builtin__array_get_with_check_u64' }
            else { 'builtin__array_get_with_check' }
        }
    }
    array_set_fn := if node.is_gated {
        'builtin__array_set_ni'
    } else {
        match wide_index_kind {
            .signed_64 { 'builtin__array_set_i64' }
            .unsigned_64 { 'builtin__array_set_u64' }
            else { 'builtin__array_set' }
        }
    }
    // `vals[i].field = x` is an exception and requires `array_get`:
    // `(*(Val*)array_get(vals, i)).field = x;`
    if g.is_assign_lhs && node.is_setter {
        is_direct_array_access := !node.is_gated && wide_index_kind == .plain
            && (g.is_direct_array_access || node.is_direct)
        is_op_assign := g.assign_op != .assign && info.elem_type != ast.string_type
        if is_direct_array_access {
            g.write('((${elem_type_str}*)')
        } else if is_op_assign {
            g.write('(*(${elem_type_str}*)${array_get_fn}(')
            if left_is_ptr && !left_is_shared {
                g.write('*')
            }
        } else {
            g.cur_indexexpr << node.pos.pos
            g.is_arraymap_set = true // special handling of assign_op and closing with '})'
            g.write('${array_set_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 node.index !is ast.RangeExpr && left_is_ptr {
                g.write('->val')
            } else {
                g.write('.val')
            }
        }
        if is_direct_array_access {
            if left_is_ptr && !left_is_shared {
                g.write('->')
            } else {
                g.write('.')
            }
            g.write('data)[')
            g.expr(node.index)
            g.write(']')
        } else {
            g.write(', ')
            g.expr(node.index)
            if !is_op_assign {
                mut need_wrapper := true
                /*
                match node.right {
                                ast.EnumVal, ast.Ident {
                                    // `&x` is enough for variables and enums
                                    // `&(Foo[]){ ... }` is only needed for function calls and literals
                                    need_wrapper = false
                                }
                                else {}
                            }
                */
                if elem_sym.kind != .array_fixed {
                    if need_wrapper {
                        g.write(', &(${elem_type_str}[]) { ')
                    } else {
                        g.write(', &')
                    }
                }
            } else {
                // `x[0] *= y`
                g.write('))')
            }
        }
    } else {
        is_direct_array_access := !node.is_gated && wide_index_kind == .plain
            && (g.is_direct_array_access || node.is_direct)
        is_fn_index_call := g.is_fn_index_call && elem_sym.info is ast.FnType
        // do not clone inside `opt_ok(opt_ok(&(string[]) {..})` before returns
        needs_clone := info.elem_type == ast.string_type_idx && g.is_autofree && !(g.inside_return
            && g.fn_decl != unsafe { nil } && g.fn_decl.return_type.has_flag(.option))
            && !g.is_assign_lhs
        is_gen_or_and_assign_rhs := gen_or && !g.discard_or_result
        cur_line := if is_gen_or_and_assign_rhs {
            line := g.go_before_last_stmt()
            g.out.write_string(util.tabs(g.indent))
            line
        } else {
            ''
        }
        tmp_opt := if gen_or { g.new_tmp_var() } else { '' }
        tmp_opt_ptr := if gen_or { g.new_tmp_var() } else { '' }
        if gen_or {
            g.write('${elem_type_str}* ${tmp_opt_ptr} = (${elem_type_str}*)(${array_get_with_check_fn}(')
            if left_is_ptr && !left_is_shared {
                g.write('*')
            }
        } else {
            if needs_clone {
                g.write('builtin__string_clone(')
            }
            if is_fn_index_call {
                if elem_sym.info is ast.FnType {
                    g.write('((')
                    g.write_fn_ptr_decl(&elem_sym.info, '')
                    if is_direct_array_access {
                        g.write(')((${elem_type_str}*)')
                    } else {
                        g.write(')(*(${elem_type_str}*)${array_get_fn}(')
                    }
                }
                if left_is_ptr && !left_is_shared && !is_direct_array_access {
                    g.write('*')
                }
            } else if is_direct_array_access {
                g.write('((${elem_type_str}*)')
            } else {
                g.write('(*(${elem_type_str}*)${array_get_fn}(')
                if left_is_ptr && !left_is_shared {
                    g.write('*')
                }
            }
        }
        g.expr(ast.Expr(node.left))
        // TODO: test direct_array_access when 'shared' is implemented
        if left_is_shared {
            if left_is_ptr {
                g.write('->val')
            } else {
                g.write('.val')
            }
        }
        if is_direct_array_access && !gen_or {
            if left_is_ptr && !left_is_shared {
                g.write('->')
            } else {
                g.write('.')
            }
            g.write('data)[')
            g.expr(node.index)
            g.write(']')
            if is_fn_index_call {
                g.write(')')
            }
        } else {
            g.write(', ')
            g.expr(node.index)
            if is_fn_index_call {
                g.write(')))')
            } else {
                g.write('))')
            }
        }
        if !gen_or && needs_clone {
            g.write(')')
        }
        if gen_or {
            g.writeln(';')
            opt_elem_type := g.styp(elem_type.set_flag(.option))
            g.writeln('${opt_elem_type} ${tmp_opt} = {0};')
            g.writeln('if (${tmp_opt_ptr}) {')
            if elem_type.has_flag(.option) && !g.inside_opt_or_res {
                g.writeln('\tif (${tmp_opt_ptr}->state == 0) {')
                g.writeln('\t\t*((${result_type_str}*)&${tmp_opt}.data) = *((${result_type_str}*)${tmp_opt_ptr}->data);')
                g.writeln('\t} else {')
                g.writeln('\t\t${tmp_opt}.state = ${tmp_opt_ptr}->state;')
                g.writeln('\t\t${tmp_opt}.err = ${tmp_opt_ptr}->err;')
                g.writeln('\t}')
            } else {
                g.writeln('\t*((${elem_type_str}*)&${tmp_opt}.data) = *((${elem_type_str}*)${tmp_opt_ptr});')
            }
            g.writeln('} else {')
            g.writeln('\t${tmp_opt}.state = 2; ${tmp_opt}.err = builtin___v_error(_S("array index out of range"));')
            g.writeln('}')
            if !node.is_option {
                g.or_block(tmp_opt, node.or_expr, elem_type)
            }
            if is_gen_or_and_assign_rhs {
                g.set_current_pos_as_last_stmt_pos()
            }
            if !g.is_amp {
                if g.inside_opt_or_res && elem_type.has_flag(.option) && g.inside_assign {
                    g.write('\n${cur_line}(*(${elem_type_str}*)&${tmp_opt})')
                } else if elem_type.has_flag(.option) && !g.inside_opt_or_res {
                    g.write('\n${cur_line}(*(${result_type_str}*)${tmp_opt}.data)')
                } else {
                    g.write('\n${cur_line}(*(${elem_type_str}*)${tmp_opt}.data)')
                }
            } else {
                g.write('\n${cur_line}*${tmp_opt_ptr}')
            }
        }
    }
}

fn (mut g Gen) index_of_fixed_array(node ast.IndexExpr, sym ast.TypeSymbol) {
    info := sym.info as ast.ArrayFixed
    elem_type := info.elem_type
    elem_sym := g.table.sym(elem_type)
    is_fn_index_call := g.is_fn_index_call && elem_sym.info is ast.FnType
    wide_index_kind := g.c_wide_index_kind(node.index_type)

    if node.left is ast.ArrayInit {
        past := g.past_tmp_var_new()
        styp := g.styp(node.left_type)
        g.write('${styp} ${past.tmp_var} = ')
        g.expr(ast.Expr(node.left))
        g.writeln(';')
        g.past_tmp_var_done(past)
    } else if node.left is ast.IndexExpr && node.left.is_setter {
        line := g.go_before_last_stmt().trim_space()
        g.empty_line = true
        tmp_var := g.new_tmp_var()
        styp := g.styp(node.left_type)
        g.write('${styp}* ${tmp_var} = &')
        g.expr(ast.Expr(node.left))
        g.writeln(';')
        g.write(line)
        g.write('(*')
        g.write(tmp_var)
        g.write(')')
    } else {
        if is_fn_index_call {
            g.write('(*')
        }
        if node.left_type.is_ptr() || node.left.is_auto_deref_var() {
            g.write('(*')
            g.expr(ast.Expr(node.left))
            g.write(')')
        } else {
            g.expr(ast.Expr(node.left))
        }
        if node.left_type.has_flag(.shared_f) {
            g.write('.val')
        }
    }
    g.write('[')
    if node.is_gated {
        g.write('builtin__v_fixed_index_ni(')
        g.expr(node.index)
        g.write(', ${info.size})')
    } else if wide_index_kind == .signed_64 {
        g.write('builtin__v_fixed_index_i64(')
        g.expr(node.index)
        g.write(', ${info.size})')
    } else if wide_index_kind == .unsigned_64 {
        g.write('builtin__v_fixed_index_u64(')
        g.expr(node.index)
        g.write(', ${info.size})')
    } else if g.is_direct_array_access || g.pref.translated || node.index is ast.IntegerLiteral {
        g.expr(node.index)
    } else {
        // bounds check
        g.write('builtin__v_fixed_index(')
        g.expr(node.index)
        g.write(', ${info.size})')
    }
    g.write(']')
    if is_fn_index_call {
        g.write(')')
    }
}

fn (mut g Gen) index_of_map(node ast.IndexExpr, sym ast.TypeSymbol) {
    gen_or := node.or_expr.kind != .absent || node.is_option
    mut map_left_type := g.recheck_concrete_type(node.left_type)
    resolved_left_type := g.recheck_concrete_type(g.resolved_expr_type(node.left, node.left_type))
    if resolved_left_type != 0
        && (g.cur_concrete_types.len > 0 || map_left_type == 0 || map_left_type.has_flag(.generic)
        || g.type_has_unresolved_generic_parts(map_left_type)
        || g.unwrap_generic(resolved_left_type) != g.unwrap_generic(map_left_type)) {
        map_left_type = resolved_left_type
    }
    mut left_is_ptr := map_left_type.is_ptr()
    if !left_is_ptr && g.is_assign_lhs && node.left is ast.Ident
        && g.resolved_ident_is_auto_heap(node.left) {
        left_is_ptr = true
    }
    left_sym := if map_left_type != 0 {
        *g.table.final_sym(g.unwrap_generic(map_left_type))
    } else {
        sym
    }
    info := if left_sym.kind == .map {
        left_sym.info as ast.Map
    } else {
        sym.info as ast.Map
    }
    mut key_type := g.unwrap_generic(g.recheck_concrete_type(info.key_type))
    mut val_type := g.unwrap_generic(g.recheck_concrete_type(info.value_type))
    if key_type == 0 {
        key_type = info.key_type
    }
    if val_type == 0 {
        val_type = info.value_type
    }
    if node.left is ast.Ident {
        ident_key_type := g.resolved_ident_map_key_type(node.left)
        if ident_key_type != 0 {
            key_type = ident_key_type
        }
        ident_val_type := g.resolved_ident_map_value_type(node.left)
        if ident_val_type != 0 {
            val_type = ident_val_type
        }
    }
    if key_type == ast.usize_type || val_type == ast.usize_type {
        name_key_type, name_val_type := g.resolved_map_types_from_name(left_sym.name)
        if key_type == ast.usize_type && name_key_type != 0 {
            key_type = name_key_type
        }
        if val_type == ast.usize_type && name_val_type != 0 {
            val_type = name_val_type
        }
    }
    if val_type == ast.usize_type && node.typ != 0 {
        candidate_val_type := g.unwrap_generic(g.recheck_concrete_type(node.typ))
        if candidate_val_type != 0 && candidate_val_type != ast.void_type
            && candidate_val_type !in [ast.int_literal_type, ast.float_literal_type] {
            val_type = candidate_val_type
        }
    }
    val_sym := g.table.final_sym(val_type)
    left_is_shared := map_left_type.has_flag(.shared_f)
    val_type_str := if val_sym.kind == .function {
        'voidptr'
    } else {
        if g.inside_return {
            g.styp(val_type)
        } else {
            g.styp(val_type.clear_flag(.result))
        }
    }
    get_and_set_types := val_sym.kind in [.struct, .map, .array, .array_fixed]
    use_get_and_set := g.inside_left_shift || (node.is_setter && !g.inside_map_infix)
    if g.is_assign_lhs && !g.is_arraymap_set && !get_and_set_types {
        if g.assign_op == .assign || val_type == ast.string_type {
            g.cur_indexexpr << node.pos.pos
            g.is_arraymap_set = true
            g.write('builtin__map_set(')
        } else {
            if use_get_and_set {
                g.write('(*((${val_type_str}*)builtin__map_get_and_set((map*)')
            } else {
                g.write('(*((${val_type_str}*)builtin__map_get((map*)')
            }
        }
        if !left_is_ptr || left_is_shared {
            g.write('&')
        }
        if node.left is ast.IndexExpr {
            g.inside_map_index = true
            g.expr(ast.Expr(node.left))
            g.inside_map_index = false
        } else {
            g.expr(node.left)
        }
        if left_is_shared {
            g.write('->val')
        }
        g.write(', ')
        old_is_arraymap_set := g.is_arraymap_set
        old_is_assign_lhs := g.is_assign_lhs
        g.is_arraymap_set = false
        g.is_assign_lhs = false
        g.write_map_key_arg(node.index, key_type)
        g.is_arraymap_set = old_is_arraymap_set
        g.is_assign_lhs = old_is_assign_lhs
        g.arraymap_set_pos = g.out.len
        g.write(', &(${val_type_str}[]) { ')
        if g.assign_op != .assign && val_type != ast.string_type {
            zero := g.type_default(val_type)
            g.write('${zero} })))')
        }
    } else if !gen_or && (g.inside_map_postfix || g.inside_map_infix
        || g.inside_map_index || g.inside_array_index || g.inside_left_shift
        || (g.is_assign_lhs && !g.is_arraymap_set && get_and_set_types)) {
        zero := g.type_default(val_type)
        if use_get_and_set {
            g.write('(*(${val_type_str}*)builtin__map_get_and_set((map*)')
        } else {
            g.write('(*(${val_type_str}*)builtin__map_get((map*)')
        }
        if !left_is_ptr || left_is_shared {
            g.write('&')
        }
        g.expr(node.left)
        if left_is_shared {
            g.write('->val')
        }
        g.write(', ')
        old_is_assign_lhs := g.is_assign_lhs
        g.is_assign_lhs = false
        g.write_map_key_arg(node.index, key_type)
        g.is_assign_lhs = old_is_assign_lhs
        g.write(', &(${val_type_str}[]){ ${zero} }))')
    } else {
        zero := g.type_default(val_type)
        is_gen_or_and_assign_rhs := gen_or && !g.discard_or_result
        cur_line := if is_gen_or_and_assign_rhs {
            line := g.go_before_last_stmt()
            g.out.write_string(util.tabs(g.indent))
            line
        } else {
            ''
        }
        tmp_opt := if gen_or { g.new_tmp_var() } else { '' }
        tmp_opt_ptr := if gen_or { g.new_tmp_var() } else { '' }
        mut is_fn_last_index_call := false
        if gen_or {
            g.write('${val_type_str}* ${tmp_opt_ptr} = (${val_type_str}*)(builtin__map_get_check(')
        } else {
            if g.is_fn_index_call {
                if val_sym.info is ast.FnType {
                    g.write('((')
                    g.write_fn_ptr_decl(&val_sym.info, '')
                    g.write(')(*(voidptr*)builtin__map_get(')
                    is_fn_last_index_call = true
                    g.is_fn_index_call = false
                }
            } else {
                g.write('(*(${val_type_str}*)builtin__map_get(')
            }
        }
        if !left_is_ptr || left_is_shared {
            g.write('ADDR(map, ')
            g.expr(node.left)
        } else {
            g.write('(')
            g.expr(node.left)
        }
        if left_is_shared {
            if left_is_ptr {
                g.write('->val')
            } else {
                g.write('.val')
            }
        }
        g.write('), ')
        g.write_map_key_arg(node.index, key_type)
        if gen_or {
            g.write('))')
        } else if is_fn_last_index_call {
            g.write(', &(voidptr[]){ ${zero} })))')
        } else {
            g.write(', &(${val_type_str}[]){ ${zero} }))')
        }
        if gen_or {
            g.writeln(';')
            // The surrounding expression may already carry a pointer prefix placeholder.
            direct_ptr_cur_line := if cur_line.ends_with('&') || cur_line.ends_with('H') {
                cur_line[..cur_line.len - 1]
            } else {
                cur_line
            }
            if g.unsafe_level > 0 && !node.is_option && !node.is_setter
                && node.or_expr.kind == .block && node.or_expr.stmts.len == 1 {
                last_stmt := node.or_expr.stmts[0]
                if last_stmt is ast.ExprStmt && last_stmt.typ.is_any_kind_of_pointer() {
                    // handle the case of `p := unsafe{ &m[key] or { nil } }` directly, without an intermediate option + copies etc:
                    g.write('if (!${tmp_opt_ptr}) { ${tmp_opt_ptr} = ')
                    g.expr(last_stmt.expr)
                    g.write('; }')
                    if cur_line.ends_with('&') || cur_line.ends_with('H') {
                        g.write('\n${direct_ptr_cur_line}${tmp_opt_ptr}')
                    } else {
                        g.write('\n${cur_line}(*${tmp_opt_ptr})')
                    }
                    return
                }
            }
            if val_type.has_flag(.option) {
                or_value_type := g.resolved_or_block_value_type(node.or_expr)
                keep_option_result := node.is_option || (node.or_expr.kind == .block
                    && (or_value_type in [ast.none_type, ast.none_type_idx]
                    || or_value_type.has_flag(.option)))
                plain_val_type := val_type.clear_option_and_result()
                plain_val_sym := g.table.final_sym(plain_val_type)
                plain_val_type_str := if plain_val_sym.kind == .function {
                    'voidptr'
                } else {
                    g.styp(plain_val_type)
                }
                g.writeln('${val_type_str} ${tmp_opt} = {0};')
                g.writeln('if (${tmp_opt_ptr}) {')
                g.writeln('\t${tmp_opt} = *${tmp_opt_ptr};')
                g.writeln('} else {')
                g.writeln('\t${tmp_opt}.state = 2; ${tmp_opt}.err = builtin___v_error(_S("map key does not exist"));')
                g.writeln('}')
                if !node.is_option {
                    g.or_block_on_value(tmp_opt, node.or_expr, val_type)
                }
                if is_gen_or_and_assign_rhs {
                    g.set_current_pos_as_last_stmt_pos()
                }
                if keep_option_result {
                    g.write('\n${cur_line}${tmp_opt}')
                } else {
                    g.write('\n${cur_line}(*(${plain_val_type_str}*)${tmp_opt}.data)')
                }
            } else {
                opt_val_type := g.styp(val_type.set_flag(.option))
                g.writeln('${opt_val_type} ${tmp_opt} = {0};')
                g.writeln('if (${tmp_opt_ptr}) {')
                if val_sym.kind == .array_fixed {
                    g.writeln('\tmemcpy((${val_type_str}*)${tmp_opt}.data, (${val_type_str}*)${tmp_opt_ptr}, sizeof(${val_type_str}));')
                } else {
                    g.writeln('\t*((${val_type_str}*)&${tmp_opt}.data) = *((${val_type_str}*)${tmp_opt_ptr});')
                }
                g.writeln('} else {')
                g.writeln('\t${tmp_opt}.state = 2; ${tmp_opt}.err = builtin___v_error(_S("map key does not exist"));')
                g.writeln('}')
                if !node.is_option {
                    g.or_block(tmp_opt, node.or_expr, val_type)
                }
                if is_gen_or_and_assign_rhs {
                    g.set_current_pos_as_last_stmt_pos()
                }
                g.write('\n${cur_line}(*(${val_type_str}*)${tmp_opt}.data)')
            }
        }
    }
}