module c

import v3.flat
import v3.types

// array_like_type supports array like type handling for c.
fn array_like_type(t types.Type) ?types.Array {
	if t is types.Array {
		return t
	}
	if t is types.Alias {
		base := t.base_type
		if base is types.Array {
			return base
		}
	}
	return none
}

// array_fixed_type supports array fixed type handling for c.
fn array_fixed_type(t types.Type) ?types.ArrayFixed {
	if t is types.ArrayFixed {
		return t
	}
	if t is types.Alias {
		base := t.base_type
		if base is types.ArrayFixed {
			return base
		}
	}
	return none
}

fn fixed_array_index_info(t types.Type) (bool, bool, types.ArrayFixed) {
	if fixed := array_fixed_type(t) {
		return true, false, fixed
	}
	if t is types.Pointer {
		if fixed := array_fixed_type(t.base_type) {
			return true, true, fixed
		}
	}
	return false, false, types.ArrayFixed{}
}

// gen_array_literal_value emits array literal value output for c.
fn (mut g FlatGen) gen_array_literal_value(node flat.Node, elem_type types.Type) {
	c_elem := g.value_c_type(elem_type)
	sizeof_elem := g.value_sizeof_target(elem_type)
	count := node.children_count
	if count == 0 {
		g.write('array_new(sizeof(${sizeof_elem}), 0, 0)')
		return
	}
	g.write('new_array_from_c_array(${count}, ${count}, sizeof(${sizeof_elem}), (${c_elem}[]){')
	for i in 0 .. count {
		if i > 0 {
			g.write(', ')
		}
		// Emit each element against the concrete element type, not the enclosing
		// `expected_expr_type` (which is the whole array). A bare generic struct element
		// (`Box{..}` in a `[]Box[int]` literal) otherwise sees the array type, fails the
		// `generic_struct_init_instance_type` array skip, and is emitted as the bare `Box`
		// while the array storage is `Box_int` — incompatible C.
		g.gen_expr_with_expected_type(g.a.child(&node, i), elem_type)
	}
	g.write('})')
}

fn (mut g FlatGen) gen_array_literal_ptr_arg(node flat.Node, elem_type types.Type) {
	c_elem := g.value_c_type(elem_type)
	g.write('(${c_elem}[]){')
	for i in 0 .. node.children_count {
		if i > 0 {
			g.write(', ')
		}
		g.gen_expr_with_expected_type(g.a.child(&node, i), elem_type)
	}
	if node.children_count == 0 {
		g.write('0')
	}
	g.write('}')
}

fn (mut g FlatGen) gen_pointer_arg_from_array_literal(node flat.Node, expected types.Type) bool {
	if node.kind != .array_literal {
		return false
	}
	if expected is types.Pointer {
		g.gen_array_literal_ptr_arg(node, expected.base_type)
		return true
	}
	return false
}

// gen_fixed_array_data_arg emits fixed array data arg output for c.
fn (mut g FlatGen) gen_fixed_array_data_arg(id flat.NodeId, arr types.ArrayFixed) {
	node := g.a.nodes[int(id)]
	if node.kind == .array_literal {
		c_elem := g.value_c_type(arr.elem_type)
		g.write('(${c_elem}[]){')
		for i in 0 .. node.children_count {
			if i > 0 {
				g.write(', ')
			}
			g.gen_expr(g.a.child(&node, i))
		}
		g.write('}')
		return
	}
	if node.kind == .paren && node.children_count > 0 {
		g.gen_fixed_array_data_arg(g.a.child(&node, 0), arr)
		return
	}
	if node.kind == .postfix && node.children_count > 0 {
		child_id := g.a.child(&node, 0)
		child := g.a.nodes[int(child_id)]
		if child.kind == .array_literal {
			g.gen_fixed_array_data_arg(child_id, arr)
			return
		}
	}
	// A fixed-array value (e.g. `[4]u8` color) is sometimes represented as a dynamic
	// `Array`; a C fixed-array parameter decays to `elem*`, so pass the data pointer.
	if g.tc.resolve_type(id) is types.Array {
		elem_ct := g.tc.c_type(arr.elem_type)
		g.write('(${elem_ct}*)(')
		g.gen_expr(id)
		g.write(').data')
		return
	}
	g.gen_expr(id)
}

// gen_array_push_many_stmt emits array push many stmt output for c.
fn (mut g FlatGen) gen_array_push_many_stmt(lhs_id flat.NodeId, rhs_id flat.NodeId) {
	lhs_is_ptr := g.tc.resolve_type(lhs_id) is types.Pointer
	amp := if lhs_is_ptr { '' } else { '&' }
	rhs_type := types.unwrap_pointer(g.tc.resolve_type(rhs_id))
	if rhs_fixed := array_fixed_type(rhs_type) {
		g.write('array_push_many_ptr(${amp}')
		gen_expr_lvalue(mut g, lhs_id)
		g.write(', ')
		g.gen_fixed_array_data_arg(rhs_id, rhs_fixed)
		len_expr := g.fixed_array_len_value(rhs_fixed)
		g.writeln(', ${len_expr});')
		return
	}
	tmp := g.tmp_name()
	g.write('{ Array ${tmp} = ')
	g.gen_expr(rhs_id)
	g.writeln(';')
	g.write('array__push_many(${amp}')
	gen_expr_lvalue(mut g, lhs_id)
	g.writeln(', ${tmp}.data, ${tmp}.len); }')
}

// gen_slice_expr emits slice expr output for c.
fn (mut g FlatGen) gen_slice_expr(node flat.Node, base_id flat.NodeId, base_type types.Type) {
	start_node := g.a.child_node(&node, 1)
	has_start := start_node.kind != .empty
	has_end := node.children_count > 2
	base_str := g.expr_to_string(base_id)
	is_array, is_ptr, _ := array_index_info(base_type)
	is_fixed_array, fixed_is_ptr, fixed := fixed_array_index_info(base_type)
	start_str := if has_start { g.expr_to_string(g.a.child(&node, 1)) } else { '0' }
	end_str := if has_end {
		g.expr_to_string(g.a.child(&node, 2))
	} else if is_fixed_array {
		g.fixed_array_len_value(fixed)
	} else if is_array && is_ptr {
		'${base_str}->len'
	} else {
		'${base_str}.len'
	}
	if base_type is types.String {
		g.write('string__substr(${base_str}, ${start_str}, ${end_str})')
	} else if is_fixed_array {
		c_elem := g.tc.c_type(fixed.elem_type)
		data_str := if fixed_is_ptr { '(*${base_str})' } else { base_str }
		// Evaluate the slice bounds once so side-effecting expressions such as
		// `arr[i++..limit()]` are not run multiple times in the generated C.
		start_tmp := g.tmp_name()
		count_tmp := g.tmp_name()
		g.write('({ int ${start_tmp} = (${start_str}); int ${count_tmp} = (${end_str}) - ${start_tmp}; new_array_from_c_array(${count_tmp}, ${count_tmp}, sizeof(${c_elem}), &${data_str}[${start_tmp}]); })')
	} else if is_array {
		arr_str := if is_ptr { '*${base_str}' } else { base_str }
		g.write('array_slice(${arr_str}, ${start_str}, ${end_str})')
	} else {
		g.write('string__substr(${base_str}, ${start_str}, ${end_str})')
	}
}

// gen_array_method_call emits array method call output for c.
fn (mut g FlatGen) gen_array_method_call(node flat.Node, fn_node &flat.Node, arr types.Array) {
	c_elem := g.value_c_type(arr.elem_type)
	base_id := g.a.child(fn_node, 0)
	base_node := g.a.nodes[int(base_id)]
	is_ptr := if base_node.kind == .ident {
		g.tc.resolve_type(base_id) is types.Pointer
	} else {
		false
	}
	dot := if is_ptr { '->' } else { '.' }
	match fn_node.value {
		'clone' {
			g.write('array__clone(')
			if !is_ptr {
				g.write('&')
			}
			g.gen_expr(base_id)
			g.write(')')
		}
		'last' {
			g.write('*(${c_elem}*)array_get(')
			g.gen_expr(base_id)
			g.write(', ')
			g.gen_expr(base_id)
			g.write('.len - 1)')
		}
		'first' {
			g.write('*(${c_elem}*)array_get(')
			g.gen_expr(base_id)
			g.write(', 0)')
		}
		'delete_last' {
			g.write('array__delete_last(')
			if !is_ptr {
				g.write('&')
			}
			g.gen_expr(base_id)
			g.write(')')
		}
		'pop' {
			amp := if is_ptr { '' } else { '&' }
			g.write('*(${c_elem}*)array__pop(${amp}')
			g.gen_expr(base_id)
			g.write(')')
		}
		'pop_left' {
			amp := if is_ptr { '' } else { '&' }
			g.write('*(${c_elem}*)array__pop_left(${amp}')
			g.gen_expr(base_id)
			g.write(')')
		}
		'clear' {
			amp := if is_ptr { '' } else { '&' }
			g.write('array__clear(${amp}')
			g.gen_expr(base_id)
			g.write(')')
		}
		'push_many' {
			amp := if is_ptr { '' } else { '&' }
			g.write('array_push_many_ptr(${amp}')
			g.gen_expr(base_id)
			g.write(', ')
			g.gen_expr(g.a.child(&node, 1))
			g.write(', ')
			g.gen_expr(g.a.child(&node, 2))
			g.write(')')
		}
		'repeat' {
			g.write('array__repeat_to_depth(')
			g.gen_expr(base_id)
			g.write(', ')
			g.gen_expr(g.a.child(&node, 1))
			g.write(', 0)')
		}
		'repeat_to_depth' {
			g.write('array__repeat_to_depth(')
			g.gen_expr(base_id)
			g.write(', ')
			g.gen_expr(g.a.child(&node, 1))
			g.write(', ')
			g.gen_expr(g.a.child(&node, 2))
			g.write(')')
		}
		'trim' {
			amp := if is_ptr { '' } else { '&' }
			g.write('array__trim(${amp}')
			g.gen_expr(base_id)
			g.write(', ')
			g.gen_expr(g.a.child(&node, 1))
			g.write(')')
		}
		'ensure_cap' {
			amp := if is_ptr { '' } else { '&' }
			g.write('array_ensure_cap(${amp}')
			g.gen_expr(base_id)
			g.write(', ')
			g.gen_expr(g.a.child(&node, 1))
			g.write(')')
		}
		'delete' {
			amp := if is_ptr { '' } else { '&' }
			g.write('array_delete(${amp}')
			g.gen_expr(base_id)
			g.write(', ')
			g.gen_expr(g.a.child(&node, 1))
			g.write(')')
		}
		'prepend' {
			amp := if is_ptr { '' } else { '&' }
			g.write('array__prepend(${amp}')
			g.gen_expr(base_id)
			g.write(', &(${c_elem}[]){')
			g.gen_expr(g.a.child(&node, 1))
			g.write('})')
		}
		'free' {
			g.write('array__free(')
			if !is_ptr {
				g.write('&')
			}
			g.gen_expr(base_id)
			g.write(')')
		}
		'pointers' {
			g.gen_array_pointers_expr(base_id, is_ptr)
		}
		'str' {
			amp := if is_ptr { '' } else { '&' }
			g.write('strings__Builder__str(${amp}')
			g.gen_expr(base_id)
			g.write(')')
		}
		'join' {
			g.write('Array_string__join(')
			g.gen_expr(base_id)
			g.write(', ')
			g.gen_expr(g.a.child(&node, 1))
			g.write(')')
		}
		'bytestr' {
			g.write('u8__vstring_with_len((u8*)')
			g.gen_expr(base_id)
			g.write('${dot}data, ')
			g.gen_expr(base_id)
			g.write('${dot}len)')
		}
		'contains' {
			contains_fn := 'array_contains_${array_lookup_suffix(arr.elem_type)}'
			g.write('${contains_fn}(')
			g.gen_expr(base_id)
			g.write(', ')
			g.gen_expr(g.a.child(&node, 1))
			g.write(')')
		}
		'index' {
			index_fn := 'array_index_${array_lookup_suffix(arr.elem_type)}'
			g.write('${index_fn}(')
			g.gen_expr(base_id)
			g.write(', ')
			g.gen_expr(g.a.child(&node, 1))
			g.write(')')
		}
		'last_index' {
			if suffix := array_last_index_suffix(arr.elem_type) {
				index_fn := 'array_last_index_${suffix}'
				g.write('${index_fn}(')
				g.gen_expr(base_id)
				g.write(', ')
				g.gen_expr(g.a.child(&node, 1))
				g.write(')')
			} else {
				g.write('array_last_index_raw(')
				g.gen_expr(base_id)
				g.write(', &(${c_elem}[]){')
				g.gen_expr_with_expected_type(g.a.child(&node, 1), arr.elem_type)
				g.write('})')
			}
		}
		'hex' {
			g.write('Array_u8__hex(')
			if base_node.kind == .array_literal {
				g.gen_expr_with_expected_type(base_id, types.Type(types.Array{
					elem_type: types.Type(types.u8_)
				}))
			} else {
				g.gen_expr(base_id)
			}
			g.write(')')
		}
		'wait' {
			// Only a thread array supports `.wait()` (joining every spawned thread and,
			// for non-void payloads, collecting their return values into a fresh `[]T`).
			// The element carries the thread payload in its name (`thread`/`thread T`).
			// Any other element type is not a thread, so route it through the normal
			// method fallback instead of joining arbitrary array data as pthread_t handles.
			mut is_thread := false
			elem := arr.elem_type
			if elem is types.Struct {
				tn := elem.name.trim_space()
				is_thread = tn == 'thread' || tn.starts_with('thread ')
			}
			if is_thread {
				g.gen_thread_array_wait(base_id, is_ptr, arr.elem_type)
			} else {
				g.gen_array_method_call_fallback(node, fn_node.value, base_id, is_ptr, arr)
			}
		}
		else {
			g.gen_array_method_call_fallback(node, fn_node.value, base_id, is_ptr, arr)
		}
	}
}

// gen_array_method_call_fallback emits a call for an array method that has no dedicated
// codegen arm: it resolves a `[]T.method` function when one is registered, and otherwise
// emits the selector itself as a direct call. Shared by the catch-all `else` arm and by
// `.wait()` on non-thread arrays (which is unsupported and falls through here rather than
// joining elements as thread handles).
fn (mut g FlatGen) gen_array_method_call_fallback(node flat.Node, mname string, base_id flat.NodeId, is_ptr bool, arr types.Array) {
	best_mname := g.array_method_fallback_for_receiver(mname, arr)
	if best_mname.len > 0 {
		g.write(c_name(best_mname))
		g.write('(')
		ptypes := g.tc.fn_param_types[best_mname]
		wants_ptr := ptypes.len > 0 && ptypes[0] is types.Pointer
		if wants_ptr && !is_ptr {
			g.write('&')
		} else if !wants_ptr && is_ptr {
			g.write('*')
		}
		g.gen_expr(base_id)
		for i in 1 .. node.children_count {
			g.write(', ')
			g.gen_expr(g.a.child(&node, i))
		}
		g.write(')')
	} else {
		g.gen_expr(g.a.child(&node, 0))
		g.write('(')
		g.gen_expr(base_id)
		g.write(')')
	}
}

// gen_array_pointers_expr emits `array.pointers()` without compiling the erased
// raw `array` builtin body, which has no concrete element type in v3 Cgen.
fn (mut g FlatGen) gen_array_pointers_expr(base_id flat.NodeId, is_ptr bool) {
	base_type := types.unwrap_pointer(g.tc.resolve_type(base_id))
	if fixed := array_fixed_type(base_type) {
		g.gen_fixed_array_pointers_expr(base_id, is_ptr, fixed)
		return
	}
	tmp := g.tmp_count
	g.tmp_count++
	src_name := '__arr_ptrs_src_${tmp}'
	res_name := '__arr_ptrs_res_${tmp}'
	idx_name := '__arr_ptrs_i_${tmp}'
	g.write('({ Array ${src_name} = ')
	if is_ptr {
		g.write('*')
	}
	g.gen_expr(base_id)
	g.write('; Array ${res_name} = array_new(sizeof(voidptr), ${src_name}.len, ${src_name}.len); for (int ${idx_name} = 0; ${idx_name} < ${src_name}.len; ${idx_name}++) { ((voidptr*)${res_name}.data)[${idx_name}] = (voidptr)((u8*)${src_name}.data + ((u64)${idx_name} * (u64)${src_name}.element_size)); } ${res_name}; })')
}

fn (mut g FlatGen) gen_fixed_array_pointers_expr(base_id flat.NodeId, is_ptr bool, fixed types.ArrayFixed) {
	tmp := g.tmp_count
	g.tmp_count++
	src_name := '__arr_ptrs_fixed_src_${tmp}'
	res_name := '__arr_ptrs_res_${tmp}'
	idx_name := '__arr_ptrs_i_${tmp}'
	len_text := g.fixed_array_len_value(fixed)
	if !is_ptr && !g.expr_is_addressable(base_id) {
		panic('fixed array .pointers receiver should be addressable after checking')
	}
	g.write('({ ')
	g.write('typeof(')
	if is_ptr {
		g.gen_expr(base_id)
	} else {
		g.write('&(')
		g.gen_expr(base_id)
		g.write(')')
	}
	g.write(') ${src_name} = ')
	if is_ptr {
		g.gen_expr(base_id)
	} else {
		g.write('&(')
		g.gen_expr(base_id)
		g.write(')')
	}
	g.write('; Array ${res_name} = array_new(sizeof(voidptr), ${len_text}, ${len_text}); for (int ${idx_name} = 0; ${idx_name} < ${len_text}; ${idx_name}++) { ((voidptr*)${res_name}.data)[${idx_name}] = (voidptr)&((*${src_name})[${idx_name}]); } ${res_name}; })')
}

// gen_thread_array_wait emits a call to the (lazily generated) wait function for a
// `[]thread T` receiver. The element type carries the thread's return type in its
// name (`thread T`); a bare `thread` denotes a void payload.
fn (mut g FlatGen) gen_thread_array_wait(base_id flat.NodeId, is_ptr bool, elem_type types.Type) {
	mut ret_name := ''
	if elem_type is types.Struct {
		trimmed := elem_type.name.trim_space()
		if trimmed != 'thread' && trimmed.starts_with('thread ') {
			ret_name = trimmed[7..].trim_space()
		}
	}
	fn_name := g.ensure_thread_arr_wait_fn(ret_name)
	g.write('${fn_name}(')
	if is_ptr {
		g.write('*')
	}
	g.gen_expr(base_id)
	g.write(')')
}

// ensure_thread_arr_wait_fn registers (once per payload type) a function that joins
// every thread handle in the array and, for a non-void payload, copies each thread's
// heap-returned value into a result `[]T` (freeing the per-thread allocation).
fn (mut g FlatGen) ensure_thread_arr_wait_fn(ret_name string) string {
	is_void := ret_name.len == 0
	// Match the ABI return type the spawn wrapper stores (gen_spawn_expr): an
	// option/result payload is `Optional_T`, a fixed-array payload its `_v_ret_*`
	// wrapper — not the bare `c_type`, or the malloc'd and read-back layouts diverge.
	ret_ct := if is_void { 'void' } else { g.fn_return_type_name(g.tc.parse_type(ret_name)) }
	key := 'threadwait|${ret_ct}'
	if name := g.spawn_wrapper_names[key] {
		return name
	}
	// Sanitize the payload C type (`Foo*`, `void*`, ...) into an identifier fragment
	// — `c_name` does not strip `*`, so a raw pointer return type would otherwise put
	// an asterisk in the helper symbol.
	name := c_name('__v_thread_arr_wait_${types.c_type_name_part(ret_ct)}')
	g.spawn_wrapper_names[key] = name
	if is_void {
		g.spawn_wrapper_defs << 'static void ${name}(Array a) { for (int __i = 0; __i < a.len; __i++) { void* __r = NULL; pthread_join((pthread_t)(((void**)a.data)[__i]), &__r); if (__r) free(__r); } }'
	} else {
		g.spawn_wrapper_defs << 'static Array ${name}(Array a) { Array __res = array_new(sizeof(${ret_ct}), a.len, a.len); for (int __i = 0; __i < a.len; __i++) { void* __r = NULL; pthread_join((pthread_t)(((void**)a.data)[__i]), &__r); if (__r) { ((${ret_ct}*)__res.data)[__i] = *(${ret_ct}*)__r; free(__r); } } return __res; }'
	}
	return name
}

// array_lookup_suffix supports array lookup suffix handling for c.
fn array_lookup_suffix(elem_type types.Type) string {
	if elem_type is types.String {
		return 'string'
	}
	if elem_type is types.Primitive {
		if elem_type.props.has(.unsigned) && elem_type.size == 8 {
			return 'u8'
		}
	}
	return 'int'
}

fn array_last_index_suffix(elem_type types.Type) ?string {
	elem_name := elem_type.name()
	return match elem_name {
		'string' { 'string' }
		'u8', 'byte' { 'u8' }
		'int' { 'int' }
		else { none }
	}
}

// array_method_fallback supports array method fallback handling for FlatGen.
fn (mut g FlatGen) array_method_fallback(method string) string {
	if method in g.array_method_cache {
		return g.array_method_cache[method]
	}
	suffix := '.${method}'
	mut best_mname := ''
	for mname, _ in g.tc.fn_param_types {
		if mname.ends_with(suffix) {
			if best_mname.len == 0 || mname.len > best_mname.len {
				best_mname = mname
			}
		}
	}
	g.array_method_cache[method] = best_mname
	return best_mname
}

fn (mut g FlatGen) array_method_fallback_for_receiver(method string, arr types.Array) string {
	key := '${arr.elem_type.name()}.${method}'
	if key in g.array_method_cache {
		return g.array_method_cache[key]
	}
	suffix := '.${method}'
	mut best_mname := ''
	for mname, ptypes in g.tc.fn_param_types {
		if !mname.ends_with(suffix) || ptypes.len == 0 {
			continue
		}
		recv := types.unwrap_pointer(ptypes[0])
		if recv is types.Array && g.array_elem_type_matches(recv.elem_type, arr.elem_type) {
			if best_mname.len == 0 || mname.len > best_mname.len {
				best_mname = mname
			}
		}
	}
	if best_mname.len == 0 {
		best_mname = g.array_method_fallback(method)
	}
	g.array_method_cache[key] = best_mname
	return best_mname
}

fn (g &FlatGen) array_elem_type_matches(expected types.Type, actual types.Type) bool {
	if expected.name() == actual.name() {
		return true
	}
	return g.tc.c_type(expected) == g.tc.c_type(actual)
}

// gen_map_ref_arg emits map ref arg output for c.
fn (mut g FlatGen) gen_map_ref_arg(base_id flat.NodeId, base_type types.Type) {
	if base_type is types.Pointer {
		g.gen_expr(base_id)
	} else {
		g.write('&')
		g.gen_expr(base_id)
	}
}

// gen_index_assign emits index assign output for c.
fn (mut g FlatGen) gen_index_assign(node flat.Node) {
	lhs_id := g.a.child(&node, 0)
	lhs := g.a.nodes[int(lhs_id)]
	if lhs.kind == .index {
		base_id := g.a.child(&lhs, 0)
		base_type := g.tc.resolve_type(base_id)
		clean_base := types.unwrap_pointer(base_type)
		if clean_base is types.Map {
			c_key := g.value_c_type(clean_base.key_type)
			c_val := g.value_c_type(clean_base.value_type)
			is_ptr := base_type is types.Pointer
			if is_ptr {
				g.write('map__set(')
			} else {
				g.write('map__set(&')
			}
			g.gen_expr(base_id)
			g.write(', &(${c_key}[]){')
			g.gen_expr_with_expected_type(g.a.child(&lhs, 1), clean_base.key_type)
			g.write('}, &(${c_val}[]){')
			g.gen_expr_with_expected_type(g.a.child(&node, 1), clean_base.value_type)
			g.writeln('});')
			return
		}
		if base_type is types.Pointer {
			ptr_type := base_type
			if ptr_type.base_type is types.Void {
				g.write('((u8*)')
				g.gen_expr(base_id)
				g.write(')[')
				g.gen_expr(g.a.child(&lhs, 1))
				g.write('] = ')
				g.gen_expr(g.a.child(&node, 1))
				g.writeln(';')
				return
			}
		}
		mut arr_type := types.Array{}
		mut is_array_base := false
		if base_type is types.Array {
			arr_type = base_type
			is_array_base = true
		} else if base_type is types.Pointer {
			ptr_type := base_type
			ptr_base := ptr_type.base_type
			if ptr_base is types.Array {
				arr_type = ptr_base
				is_array_base = true
			}
		}
		if is_array_base {
			c_elem := g.value_c_type(arr_type.elem_type)
			tmp := g.tmp_count
			g.tmp_count++
			g.write('{ array* _a${tmp} = ')
			if base_type is types.Pointer {
				g.gen_expr(base_id)
			} else {
				g.write('&')
				g.gen_expr(base_id)
			}
			g.write('; int _i${tmp} = ')
			g.gen_expr(g.a.child(&lhs, 1))
			g.write('; array__set(_a${tmp}, _i${tmp}, &(${c_elem}[]){')
			if op := compound_assign_to_infix_op(node.op) {
				if arr_type.elem_type is types.String && op == .plus {
					g.write('string__plus(')
					g.write('*(string*)array_get(*_a${tmp}, _i${tmp})')
					g.write(', ')
					g.gen_expr_as_string(g.a.child(&node, 1))
					g.write(')')
				} else {
					g.write('(')
					g.write('*(${c_elem}*)array_get(*_a${tmp}, _i${tmp})')
					g.write(' ${g.op_str(op)} ')
					g.gen_expr_with_expected_type(g.a.child(&node, 1), arr_type.elem_type)
					g.write(')')
				}
			} else {
				g.gen_expr_with_expected_type(g.a.child(&node, 1), arr_type.elem_type)
			}
			g.writeln('}); }')
			return
		}
	}
	g.gen_assign(node)
}

fn compound_assign_to_infix_op(op flat.Op) ?flat.Op {
	match op {
		.plus_assign { return flat.Op.plus }
		.minus_assign { return flat.Op.minus }
		.mul_assign { return flat.Op.mul }
		.div_assign { return flat.Op.div }
		.mod_assign { return flat.Op.mod }
		.amp_assign { return flat.Op.amp }
		.pipe_assign { return flat.Op.pipe }
		.xor_assign { return flat.Op.xor }
		.left_shift_assign { return flat.Op.left_shift }
		.right_shift_assign { return flat.Op.right_shift }
		.right_shift_unsigned_assign { return flat.Op.right_shift_unsigned }
		else { return none }
	}
}