import os

const test_vexe = os.quoted_path(@VEXE)

fn bounded_window(text string, marker string, before int, after int) string {
	pos := text.index(marker) or {
		assert false, 'missing marker: ${marker}'
		return ''
	}
	start := if pos > before { pos - before } else { 0 }
	end_limit := pos + marker.len + after
	end := if end_limit < text.len { end_limit } else { text.len }
	return text[start..end]
}

fn function_window(text string, marker string) string {
	pos := text.index(marker) or {
		assert false, 'missing marker: ${marker}'
		return ''
	}
	rest := text[pos + marker.len..]
	end_offset := rest.index('\nVV_LOC ') or { rest.len }
	return text[pos..pos + marker.len + end_offset]
}

fn function_window_containing(text string, marker string) string {
	pos := text.index(marker) or {
		assert false, 'missing marker: ${marker}'
		return ''
	}
	prefix := text[..pos]
	start := prefix.last_index('\nVV_LOC ') or { 0 }
	rest := text[start + 1..]
	end_offset := rest.index('\nVV_LOC ') or { rest.len }
	return rest[..end_offset]
}

fn test_closure_context_codegen_uses_collectable_memdup_and_ownership() {
	workdir := os.join_path(os.vtmp_dir(), 'closure_context_codegen_${os.getpid()}')
	os.mkdir_all(workdir)!
	defer {
		os.rmdir_all(workdir) or {}
	}
	source_path := os.join_path(workdir, 'main.v')
	exe_path := os.join_path(workdir, 'main')
	os.write_file(source_path, 'module main

struct Receiver {
mut:
	value int
}

@[heap]
struct PointerReceiver {
mut:
	value int
}

type IntCallback = fn (int) int

type ZeroCallback = fn () int

type ResultRequestHandler = fn (int) !

__global global_cb = fn (x int) int {
	return x
}

struct CallbackBox {
mut:
	cb IntCallback = unsafe { nil }
}

fn make_closure(seed int) fn () int {
	return fn [seed] () int {
		return seed + 1
	}
}

fn (r Receiver) read() int {
	return r.value
}

fn (mut r PointerReceiver) bump() int {
	r.value++
	return r.value
}

fn local_direct_closure() {
	big := []int{len: 200, init: index}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	_ = h(11)
}

fn local_escaped_closure(mut callbacks []IntCallback) {
	big := []int{len: 200, init: index}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	callbacks << h
}

fn local_return_fn_value(n int) IntCallback {
	big := []int{len: 200, init: index + n}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	return h
}

fn local_copy_closure(n int) int {
	big := []int{len: 200, init: index + n}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	k := h
	return k(n % 200)
}

fn takes_cb(cb IntCallback, n int) int {
	return cb(n % 200)
}

fn local_arg_closure(n int) int {
	big := []int{len: 200, init: index + n}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	return takes_cb(h, n)
}

fn local_struct_init_closure(n int) int {
	big := []int{len: 200, init: index + n}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	box := CallbackBox{
		cb: h
	}
	return box.cb(n % 200)
}

fn local_struct_assign_closure(n int) int {
	big := []int{len: 200, init: index + n}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	mut box := CallbackBox{}
	box.cb = h
	return box.cb(n % 200)
}

fn local_global_assign_closure(n int) int {
	big := []int{len: 200, init: index + n}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	global_cb = h
	return global_cb(n % 200)
}

fn local_defer_closure() {
	big := []int{len: 200, init: index}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	defer {
		_ = h(0)
	}
}

fn local_return_closure(n int) int {
	big := []int{len: 200, init: index + n}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	if n >= 0 {
		return h(n % 200)
	}
	return 0
}

fn local_call_then_return_closure(n int) int {
	big := []int{len: 200, init: index + n}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	_ = h(n % 200)
	return 0
}

fn maybe_int(n int) ?int {
	if n < 0 {
		return none
	}
	return n
}

fn result_int(n int) !int {
	if n < 0 {
		return error("negative")
	}
	return n
}

fn maybe_request(request int) ! {
	if request < 0 {
		return error("negative request")
	}
}

fn local_option_propagation_cleanup(n int) ?int {
	big := []int{len: 200, init: index + n}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	value := maybe_int(n)?
	return h(value % 200)
}

fn local_result_propagation_cleanup(n int) !int {
	big := []int{len: 200, init: index + n}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	value := result_int(n)!
	return h(value % 200)
}

fn local_result_handler_cast_closure_boundary() {
	offset := 1
	handle_request := fn [offset] (request int) ! {
		maybe_request(request)!
		_ = offset
	}
	_ = ResultRequestHandler(handle_request)
}

fn local_for_c_init_closure(n int) int {
	big := []int{len: 200, init: index + n}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	for i := takes_cb(h, n); i < 1; i++ {
		return i
	}
	return 0
}

fn local_for_c_cond_closure(n int) int {
	big := []int{len: 200, init: index + n}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	mut result := 0
	for i := 0; i < 1 && takes_cb(h, n) >= 0; i++ {
		result += i
	}
	return result
}

fn local_for_c_inc_closure(n int) int {
	big := []int{len: 200, init: index + n}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	mut result := 0
	for i := 0; i < 1; i += takes_cb(h, n) + 1 {
		result += i
	}
	return result
}

fn local_for_c_init_closure_body_tail(n int) int {
	big := []int{len: 200, init: index + n}
	mut i := 0
	mut result := 0
	for h := fn [big] (x int) int {
		return big[x % big.len]
	}; i < 2; i++ {
		result += h(i)
	}
	return result
}

fn local_for_c_init_closure_continue(n int) int {
	big := []int{len: 200, init: index + n}
	mut i := 0
	mut result := 0
	for h := fn [big] (x int) int {
		return big[x % big.len]
	}; i < 2; i++ {
		if i == 0 {
			continue
		}
		result += h(i)
	}
	return result
}

fn local_multi_for_c_init_closure_body_tail(n int) int {
	big := []int{len: 200, init: index + n}
	mut result := 0
	for h, i := fn [big] (x int) int {
		return big[x % big.len]
	}, 0; i < 2; i++ {
		result += h(i)
	}
	return result
}

fn local_for_c_body_closure_continue_cleanup(n int) int {
	mut i := 0
	for ; i < 1; i++ {
		big := []int{len: 200, init: index + n}
		h := fn [big] (x int) int {
			return big[x % big.len]
		}
		_ = h(n % 200)
		continue
	}
	return 0
}

fn local_for_c_init_closure_return_cleanup(n int) int {
	big := []int{len: 200, init: index + n}
	mut i := 0
	for h := fn [big] (x int) int {
		return big[x % big.len]
	}; i < 1; i++ {
		return h(n % 200)
	}
	return -1
}

fn local_for_c_init_closure_labeled_break_cleanup(n int) int {
	big := []int{len: 200, init: index + n}
	mut i := 0
	mut result := 0
	closure_init_break: for h := fn [big] (x int) int {
		return big[x % big.len]
	}; i < 1; i++ {
		result += h(n % 200)
		break closure_init_break
	}
	return result
}

fn local_for_c_init_escaped_closure(mut callbacks []ZeroCallback, n int) {
	big := []int{len: 200, init: index + n}
	mut i := 0
	for h := fn [big, n] () int {
		return big[n % big.len]
	}; i < 1; i++ {
		callbacks << h
	}
}

fn local_nested_for_c_init_closure_continue_outer(n int) int {
	outer_big := []int{len: 200, init: index + n}
	mut i := 0
	mut result := 0
	nested_continue_outer: for outer_h := fn [outer_big] (x int) int {
		return outer_big[x % outer_big.len]
	}; i < 2; i++ {
		inner_big := []int{len: 200, init: index + n + 10}
		mut j := 0
		for inner_h := fn [inner_big] (x int) int {
			return inner_big[x % inner_big.len]
		}; j < 1; j++ {
			result += outer_h(i) + inner_h(j)
			continue nested_continue_outer
		}
	}
	return result
}

fn local_nested_for_c_init_closure_break_outer(n int) int {
	outer_big := []int{len: 200, init: index + n}
	mut i := 0
	mut result := 0
	nested_break_outer: for outer_h := fn [outer_big] (x int) int {
		return outer_big[x % outer_big.len]
	}; i < 2; i++ {
		inner_big := []int{len: 200, init: index + n + 20}
		mut j := 0
		for inner_h := fn [inner_big] (x int) int {
			return inner_big[x % inner_big.len]
		}; j < 1; j++ {
			result += outer_h(i) + inner_h(j)
			break nested_break_outer
		}
	}
	return result
}

fn local_for_cond_closure(n int) int {
	big := []int{len: 200, init: index + n}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	mut result := 0
	for result < 1 && takes_cb(h, n) >= 0 {
		break
	}
	return result
}

fn local_for_in_cond_closure(n int) int {
	big := []int{len: 200, init: index + n}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	for value in []int{len: 1, init: takes_cb(h, n)} {
		return value
	}
	return 0
}

fn local_for_in_high_closure(n int) int {
	big := []int{len: 200, init: index + n}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	mut result := 0
	for i in 0 .. takes_cb(h, n) {
		result += i
	}
	return result
}

fn local_array_init_closure(n int) int {
	big := []int{len: 200, init: index + n}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	values := []int{len: 1, init: takes_cb(h, n)}
	return values[0]
}

fn local_if_else_condition_closure(n int) int {
	big := []int{len: 200, init: index + n}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	if n < 0 {
		return n
	} else if takes_cb(h, n) >= 0 {
		return 0
	}
	return n
}

fn local_nested_returning_closure(n int) ZeroCallback {
	big := []int{len: 200, init: index + n}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	nested := fn [h, n] () int {
		return h(n % 200)
	}
	return nested
}

fn local_nested_stored_closure(mut callbacks []ZeroCallback, n int) {
	big := []int{len: 200, init: index + n}
	h := fn [big] (x int) int {
		return big[x % big.len]
	}
	nested := fn [h, n] () int {
		return h(n % 200)
	}
	callbacks << nested
}

fn local_keyword_closure() {
	big := []int{len: 200, init: index}
	free := fn [big] (x int) int {
		return big[x % big.len]
	}
}

fn local_labeled_break_closure(n int) int {
	mut value := 0
	closure_break: for {
		big := []int{len: 200, init: index + n}
		h := fn [big] (x int) int {
			return big[x % big.len]
		}
		value = h(n % 200)
		break closure_break
	}
	return value
}

fn local_labeled_continue_closure(n int) int {
	mut value := 0
	closure_continue: for _ in 0 .. 1 {
		big := []int{len: 200, init: index + n}
		h := fn [big] (x int) int {
			return big[x % big.len]
		}
		value = h(n % 200)
		continue closure_continue
	}
	return value
}

fn local_spawn_closure() {
	big := []int{len: 200, init: index}
	h := fn [big] () {
		_ = big[0]
	}
	t := spawn h()
	t.wait()
}

fn local_go_closure() {
	big := []int{len: 200, init: index}
	h := fn [big] () {
		_ = big[0]
	}
	t := go h()
	t.wait()
}

fn main() {
	receiver := Receiver{
		value: 10
	}
	mut pointer_receiver := &PointerReceiver{
		value: 10
	}
	anon_cb := make_closure(5)
	value_cb := receiver.read
	pointer_cb := pointer_receiver.bump
	local_direct_closure()
	mut callbacks := []IntCallback{}
	local_escaped_closure(mut callbacks)
	local_spawn_closure()
	local_go_closure()
	local_defer_closure()
	local_result_handler_cast_closure_boundary()
	opt_cleanup := local_option_propagation_cleanup(-1) or { 0 }
	res_cleanup := local_result_propagation_cleanup(-1) or { 0 }
	returned_cb := local_return_fn_value(0)
	returned_nested := local_nested_returning_closure(0)
	mut zero_callbacks := []ZeroCallback{}
	local_nested_stored_closure(mut zero_callbacks, 0)
	local_keyword_closure()
	mut escaped_for_c_callbacks := []ZeroCallback{}
	local_for_c_init_escaped_closure(mut escaped_for_c_callbacks, 0)
	mut total := anon_cb() + value_cb() + pointer_cb() + local_return_closure(0)
	total += local_call_then_return_closure(0) + opt_cleanup + res_cleanup
	total += local_for_c_init_closure(0) + local_for_c_cond_closure(0) + local_for_c_inc_closure(0)
	total += local_for_c_init_closure_body_tail(0) + local_for_c_init_closure_continue(0)
	total += local_multi_for_c_init_closure_body_tail(0) + local_for_c_body_closure_continue_cleanup(0)
	total += local_for_c_init_closure_return_cleanup(0) + local_for_c_init_closure_labeled_break_cleanup(0)
	total += escaped_for_c_callbacks[0]()
	total += local_nested_for_c_init_closure_continue_outer(0) + local_nested_for_c_init_closure_break_outer(0)
	total += local_for_cond_closure(0) + local_for_in_cond_closure(0) + local_for_in_high_closure(0)
	total += local_array_init_closure(0) + local_if_else_condition_closure(0) + returned_nested()
	total += zero_callbacks[0]() + local_labeled_break_closure(0) + local_labeled_continue_closure(0)
	total += returned_cb(0) + local_copy_closure(0) + local_arg_closure(0)
	total += local_struct_init_closure(0) + local_struct_assign_closure(0) + local_global_assign_closure(0)
	println(total)
}
')!

	c_cmd := '${test_vexe} -enable-globals -gc boehm -skip-unused -o - ${os.quoted_path(source_path)}'
	c_res := os.execute(c_cmd)
	assert c_res.exit_code == 0, '${c_cmd}\n${c_res.output}'
	generated := c_res.output.replace('\r\n', '\n')
	assert !generated.contains('builtin__memdup_uncollectable')
	assert generated.contains('sizeof(builtin__closure__ClosureLiveInfo)')
	assert !generated.contains('new_map_noscan_value(sizeof(voidptr), sizeof(builtin__closure__ClosureLiveInfo)')
	assert !generated.contains('new_map_noscan_key_value(sizeof(voidptr), sizeof(builtin__closure__ClosureLiveInfo)')

	anon_window := bounded_window(generated, 'VV_LOC anon_fn___int main__make_closure(int seed) {',
		0, 900)
	assert anon_window.contains('builtin__closure__closure_create_with_data(')
	assert anon_window.contains('builtin__memdup(&(')
	assert anon_window.contains(', true)')

	value_method_call := bounded_window(generated,
		'builtin__closure__closure_create_with_data(_V_closure_main__Receiver_read_', 0, 300)
	assert value_method_call.contains('builtin__memdup(')
	assert value_method_call.contains(', true)')

	pointer_method_call := bounded_window(generated,
		'builtin__closure__closure_create_with_data(_V_closure_main__PointerReceiver_bump_', 0, 300)
	assert !pointer_method_call.contains('builtin__memdup(')
	assert pointer_method_call.contains(', false)')

	direct_fn := function_window(generated, 'void main__local_direct_closure(void) {')
	assert direct_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	escaped_fn := function_window(generated, 'void main__local_escaped_closure')
	assert !escaped_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	return_value_fn := function_window(generated, 'main__IntCallback main__local_return_fn_value')
	assert !return_value_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	copy_fn := function_window(generated, 'int main__local_copy_closure(int n) {')
	assert !copy_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	arg_fn := function_window(generated, 'int main__local_arg_closure(int n) {')
	assert !arg_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	struct_init_fn := function_window(generated, 'int main__local_struct_init_closure(int n) {')
	assert !struct_init_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	struct_assign_fn := function_window(generated, 'int main__local_struct_assign_closure(int n) {')
	assert !struct_assign_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	global_assign_fn := function_window(generated, 'int main__local_global_assign_closure(int n) {')
	assert !global_assign_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	defer_fn := function_window(generated, 'void main__local_defer_closure(void) {')
	assert !defer_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	return_fn := function_window(generated, 'int main__local_return_closure(int n) {')
	return_cleanup_pos := return_fn.index('builtin__closure__closure_try_destroy((voidptr)h);') or {
		assert false, return_fn
		return
	}
	return_tmp_pos := return_fn.index(' = h(') or {
		assert false, return_fn
		return
	}
	assert return_tmp_pos < return_cleanup_pos
	assert return_fn[return_cleanup_pos..].contains('return _')

	call_return_fn := function_window(generated,
		'int main__local_call_then_return_closure(int n) {')
	assert call_return_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	option_propagation_fn := function_window(generated,
		'main__local_option_propagation_cleanup(int n) {')
	option_call_pos := option_propagation_fn.index('main__maybe_int(n)') or {
		assert false, option_propagation_fn
		return
	}
	option_after_call := option_propagation_fn[option_call_pos..]
	option_value_pos := option_after_call.index('int value = ') or {
		assert false, option_propagation_fn
		return
	}
	option_fail_branch := option_after_call[..option_value_pos]
	option_cleanup_pos := option_fail_branch.index('builtin__closure__closure_try_destroy((voidptr)h);') or {
		assert false, option_propagation_fn
		return
	}
	option_hidden_return_pos := option_fail_branch.index('\treturn ') or {
		assert false, option_propagation_fn
		return
	}
	assert option_cleanup_pos < option_hidden_return_pos

	result_propagation_fn := function_window(generated,
		'main__local_result_propagation_cleanup(int n) {')
	result_call_pos := result_propagation_fn.index('main__result_int(n)') or {
		assert false, result_propagation_fn
		return
	}
	result_after_call := result_propagation_fn[result_call_pos..]
	result_value_pos := result_after_call.index('int value = ') or {
		assert false, result_propagation_fn
		return
	}
	result_fail_branch := result_after_call[..result_value_pos]
	result_cleanup_pos := result_fail_branch.index('builtin__closure__closure_try_destroy((voidptr)h);') or {
		assert false, result_propagation_fn
		return
	}
	result_hidden_return_pos := result_fail_branch.index('\treturn ') or {
		assert false, result_propagation_fn
		return
	}
	assert result_cleanup_pos < result_hidden_return_pos

	result_handler_anon_fn := function_window_containing(generated, 'main__maybe_request(request)')
	assert !result_handler_anon_fn.contains('builtin__closure__closure_try_destroy((voidptr)handle_request);')

	for_c_init_fn := function_window(generated, 'int main__local_for_c_init_closure(int n) {')
	assert !for_c_init_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	for_c_cond_fn := function_window(generated, 'int main__local_for_c_cond_closure(int n) {')
	assert !for_c_cond_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	for_c_inc_fn := function_window(generated, 'int main__local_for_c_inc_closure(int n) {')
	assert !for_c_inc_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	for_c_init_body_tail_fn := function_window(generated,
		'int main__local_for_c_init_closure_body_tail(int n) {')
	assert for_c_init_body_tail_fn.contains('for (;')
	for_c_init_body_tail_call_pos := for_c_init_body_tail_fn.index('result += h(') or {
		assert false, for_c_init_body_tail_fn
		return
	}
	for_c_init_body_tail_cleanup_pos := for_c_init_body_tail_fn.index('builtin__closure__closure_try_destroy((voidptr)h);') or {
		assert false, for_c_init_body_tail_fn
		return
	}
	for_c_init_body_tail_return_pos := for_c_init_body_tail_fn.index('return result;') or {
		assert false, for_c_init_body_tail_fn
		return
	}
	assert for_c_init_body_tail_call_pos < for_c_init_body_tail_cleanup_pos
	assert for_c_init_body_tail_cleanup_pos < for_c_init_body_tail_return_pos

	for_c_init_continue_fn := function_window(generated,
		'int main__local_for_c_init_closure_continue(int n) {')
	assert for_c_init_continue_fn.contains('for (;')
	for_c_init_continue_pos := for_c_init_continue_fn.index('continue;') or {
		assert false, for_c_init_continue_fn
		return
	}
	for_c_init_continue_cleanup_pos := for_c_init_continue_fn.index('builtin__closure__closure_try_destroy((voidptr)h);') or {
		assert false, for_c_init_continue_fn
		return
	}
	for_c_init_continue_return_pos := for_c_init_continue_fn.index('return result;') or {
		assert false, for_c_init_continue_fn
		return
	}
	assert for_c_init_continue_pos < for_c_init_continue_cleanup_pos
	assert for_c_init_continue_cleanup_pos < for_c_init_continue_return_pos

	multi_for_c_init_body_tail_fn := function_window(generated,
		'int main__local_multi_for_c_init_closure_body_tail(int n) {')
	assert multi_for_c_init_body_tail_fn.contains('while (true)')
	assert multi_for_c_init_body_tail_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	for_c_body_continue_fn := function_window(generated,
		'int main__local_for_c_body_closure_continue_cleanup(int n) {')
	for_c_body_continue_cleanup_pos := for_c_body_continue_fn.index('builtin__closure__closure_try_destroy((voidptr)h);') or {
		assert false, for_c_body_continue_fn
		return
	}
	for_c_body_continue_pos := for_c_body_continue_fn.index('continue;') or {
		assert false, for_c_body_continue_fn
		return
	}
	assert for_c_body_continue_cleanup_pos < for_c_body_continue_pos

	for_c_init_return_fn := function_window(generated,
		'int main__local_for_c_init_closure_return_cleanup(int n) {')
	for_c_init_return_call_pos := for_c_init_return_fn.index(' = h(') or {
		assert false, for_c_init_return_fn
		return
	}
	for_c_init_return_cleanup_pos := for_c_init_return_fn.index('builtin__closure__closure_try_destroy((voidptr)h);') or {
		assert false, for_c_init_return_fn
		return
	}
	for_c_init_return_pos := for_c_init_return_fn.index('\treturn ') or {
		assert false, for_c_init_return_fn
		return
	}
	assert for_c_init_return_call_pos < for_c_init_return_cleanup_pos
	assert for_c_init_return_cleanup_pos < for_c_init_return_pos

	for_c_init_labeled_break_fn := function_window(generated,
		'int main__local_for_c_init_closure_labeled_break_cleanup(int n) {')
	for_c_init_labeled_break_goto_pos := for_c_init_labeled_break_fn.index('goto closure_init_break__break;') or {
		assert false, for_c_init_labeled_break_fn
		return
	}
	for_c_init_labeled_break_label_pos := for_c_init_labeled_break_fn.index('closure_init_break__break: {}') or {
		assert false, for_c_init_labeled_break_fn
		return
	}
	for_c_init_labeled_break_cleanup_pos := for_c_init_labeled_break_fn.index('builtin__closure__closure_try_destroy((voidptr)h);') or {
		assert false, for_c_init_labeled_break_fn
		return
	}
	assert for_c_init_labeled_break_goto_pos < for_c_init_labeled_break_label_pos
	assert for_c_init_labeled_break_label_pos < for_c_init_labeled_break_cleanup_pos

	for_c_init_escaped_fn := function_window(generated,
		'void main__local_for_c_init_escaped_closure')
	assert !for_c_init_escaped_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	nested_continue_fn := function_window(generated,
		'int main__local_nested_for_c_init_closure_continue_outer(int n) {')
	nested_continue_inner_cleanup_pos := nested_continue_fn.index('builtin__closure__closure_try_destroy((voidptr)inner_h);') or {
		assert false, nested_continue_fn
		return
	}
	nested_continue_goto_pos := nested_continue_fn.index('goto nested_continue_outer__continue_entry;') or {
		assert false, nested_continue_fn
		return
	}
	nested_continue_outer_cleanup_pos := nested_continue_fn.index('builtin__closure__closure_try_destroy((voidptr)outer_h);') or {
		assert false, nested_continue_fn
		return
	}
	assert nested_continue_inner_cleanup_pos < nested_continue_goto_pos
	assert nested_continue_goto_pos < nested_continue_outer_cleanup_pos

	nested_break_fn := function_window(generated,
		'int main__local_nested_for_c_init_closure_break_outer(int n) {')
	nested_break_inner_cleanup_pos := nested_break_fn.index('builtin__closure__closure_try_destroy((voidptr)inner_h);') or {
		assert false, nested_break_fn
		return
	}
	nested_break_goto_pos := nested_break_fn.index('goto nested_break_outer__break;') or {
		assert false, nested_break_fn
		return
	}
	nested_break_label_pos := nested_break_fn.index('nested_break_outer__break: {}') or {
		assert false, nested_break_fn
		return
	}
	nested_break_outer_cleanup_pos := nested_break_fn.index('builtin__closure__closure_try_destroy((voidptr)outer_h);') or {
		assert false, nested_break_fn
		return
	}
	assert nested_break_inner_cleanup_pos < nested_break_goto_pos
	assert nested_break_goto_pos < nested_break_label_pos
	assert nested_break_label_pos < nested_break_outer_cleanup_pos

	for_cond_fn := function_window(generated, 'int main__local_for_cond_closure(int n) {')
	assert !for_cond_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	for_in_cond_fn := function_window(generated, 'int main__local_for_in_cond_closure(int n) {')
	assert !for_in_cond_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	for_in_high_fn := function_window(generated, 'int main__local_for_in_high_closure(int n) {')
	assert !for_in_high_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	array_init_fn := function_window(generated, 'int main__local_array_init_closure(int n) {')
	assert !array_init_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	if_condition_fn := function_window(generated,
		'int main__local_if_else_condition_closure(int n) {')
	assert !if_condition_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	nested_returning_fn := function_window(generated,
		'main__ZeroCallback main__local_nested_returning_closure(int n) {')
	assert !nested_returning_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')
	assert !nested_returning_fn.contains('builtin__closure__closure_try_destroy((voidptr)nested);')

	nested_stored_fn := function_window(generated, 'void main__local_nested_stored_closure')
	assert !nested_stored_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')
	assert !nested_stored_fn.contains('builtin__closure__closure_try_destroy((voidptr)nested);')

	keyword_fn := function_window(generated, 'void main__local_keyword_closure(void) {')
	assert keyword_fn.contains('(*_v_free)')
	assert keyword_fn.contains('builtin__closure__closure_try_destroy((voidptr)_v_free);')
	assert !keyword_fn.contains('builtin__closure__closure_try_destroy((voidptr)__v_free);')
	assert !keyword_fn.contains('builtin__closure__closure_try_destroy((voidptr)free);')

	labeled_break_fn := function_window(generated, 'int main__local_labeled_break_closure(int n) {')
	labeled_break_cleanup_pos := labeled_break_fn.index('builtin__closure__closure_try_destroy((voidptr)h);') or {
		assert false, labeled_break_fn
		return
	}
	labeled_break_goto_pos := labeled_break_fn.index('goto closure_break__break;') or {
		assert false, labeled_break_fn
		return
	}
	assert labeled_break_cleanup_pos < labeled_break_goto_pos

	labeled_continue_fn := function_window(generated,
		'int main__local_labeled_continue_closure(int n) {')
	labeled_continue_cleanup_pos := labeled_continue_fn.index('builtin__closure__closure_try_destroy((voidptr)h);') or {
		assert false, labeled_continue_fn
		return
	}
	labeled_continue_goto_pos := labeled_continue_fn.index('goto closure_continue__continue_entry;') or {
		assert false, labeled_continue_fn
		return
	}
	assert labeled_continue_cleanup_pos < labeled_continue_goto_pos

	spawn_fn := function_window(generated, 'void main__local_spawn_closure(void) {')
	assert spawn_fn.contains('/*spawn (thread) */')
	assert !spawn_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	go_fn := function_window(generated, 'void main__local_go_closure(void) {')
	assert go_fn.contains('/*spawn (thread) */') || go_fn.contains('/*go (coroutine) */')
	assert !go_fn.contains('builtin__closure__closure_try_destroy((voidptr)h);')

	compile_cmd := '${test_vexe} -enable-globals -gc none -skip-unused -o ${os.quoted_path(exe_path)} ${os.quoted_path(source_path)}'
	compile_res := os.execute(compile_cmd)
	assert compile_res.exit_code == 0, '${compile_cmd}\n${compile_res.output}'
	run_res := os.execute(os.quoted_path(exe_path))
	assert run_res.exit_code == 0, run_res.output
	assert run_res.output.trim_space() == '71'
}