// vtest build: macos
module cleanc

import os
import strings
import v2.ast
import v2.markused
import v2.parser
import v2.pref as vpref
import v2.token
import v2.transformer
import v2.types

fn generate_result_option_c_for_test(code string) string {
	return generate_result_option_c_for_test_files([code])
}

fn generate_result_option_c_for_test_files(sources []string) string {
	tmp_dir := os.join_path(os.temp_dir(), 'v2_result_option_codegen_test_${os.getpid()}')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(tmp_dir) or { panic('failed to create temp dir') }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	mut paths := []string{cap: sources.len}
	for i, code in sources {
		tmp_file := os.join_path(tmp_dir, 'file_${i}.v')
		os.write_file(tmp_file, code) or { panic('failed to write temp file') }
		paths << tmp_file
	}
	prefs := &vpref.Preferences{
		backend:     .cleanc
		no_parallel: true
	}
	mut file_set := token.FileSet.new()
	mut par := parser.Parser.new(prefs)
	files := par.parse_files(paths, mut file_set)
	env := types.Environment.new()
	mut checker := types.Checker.new(prefs, file_set, env)
	checker.check_files(files)
	mut trans := transformer.Transformer.new_with_pref(env, prefs)
	mut gen := Gen.new_with_env_and_pref(trans.transform_files(files), env, prefs)
	return gen.gen()
}

fn generate_markused_c_for_test(code string) string {
	tmp_file := os.join_path(os.temp_dir(), 'v2_markused_codegen_test_${os.getpid()}.v')
	os.write_file(tmp_file, code) or { panic('failed to write temp file') }
	defer {
		os.rm(tmp_file) or {}
	}
	prefs := &vpref.Preferences{
		backend:     .cleanc
		no_parallel: true
	}
	mut file_set := token.FileSet.new()
	mut par := parser.Parser.new(prefs)
	files := par.parse_files([tmp_file], mut file_set)
	env := types.Environment.new()
	mut checker := types.Checker.new(prefs, file_set, env)
	checker.check_files(files)
	mut trans := transformer.Transformer.new_with_pref(env, prefs)
	gen_files := trans.transform_files(files)
	used := markused.mark_used(gen_files, env)
	mut gen := Gen.new_with_env_and_pref(gen_files, env, prefs)
	gen.set_used_fn_keys(used)
	return gen.gen()
}

fn generate_ownership_markused_c_for_test(code string) string {
	tmp_file := os.join_path(os.temp_dir(), 'v2_ownership_markused_codegen_test_${os.getpid()}.v')
	os.write_file(tmp_file, code) or { panic('failed to write temp file') }
	defer {
		os.rm(tmp_file) or {}
	}
	prefs := &vpref.Preferences{
		backend:     .cleanc
		no_parallel: true
		ownership:   true
	}
	mut file_set := token.FileSet.new()
	mut par := parser.Parser.new(prefs)
	files := par.parse_files([tmp_file], mut file_set)
	env := types.Environment.new()
	mut checker := types.Checker.new(prefs, file_set, env)
	checker.check_files(files)
	mut trans := transformer.Transformer.new_with_pref(env, prefs)
	gen_files := trans.transform_files(files)
	used := markused.mark_used(gen_files, env)
	mut gen := Gen.new_with_env_and_pref(gen_files, env, prefs)
	gen.set_used_fn_keys(used)
	return gen.gen()
}

fn generate_parallel_worker_c_for_test(code string) string {
	tmp_file := os.join_path(os.temp_dir(), 'v2_parallel_worker_codegen_test_${os.getpid()}.v')
	os.write_file(tmp_file, code) or { panic('failed to write temp file') }
	defer {
		os.rm(tmp_file) or {}
	}
	prefs := &vpref.Preferences{
		backend:     .cleanc
		no_parallel: false
		ownership:   true
	}
	mut file_set := token.FileSet.new()
	mut par := parser.Parser.new(prefs)
	files := par.parse_files([tmp_file], mut file_set)
	env := types.Environment.new()
	mut checker := types.Checker.new(prefs, file_set, env)
	checker.check_files(files)
	mut trans := transformer.Transformer.new_with_pref(env, prefs)
	gen_files := trans.transform_files(files)
	used := markused.mark_used(gen_files, env)
	mut gen := Gen.new_with_env_and_pref(gen_files, env, prefs)
	gen.set_used_fn_keys(used)
	gen.gen_passes_1_to_4()
	emit_indices := gen.gen_pass5_pre()
	mut worker := gen.new_pass5_worker(emit_indices, 0)
	worker.gen_pass5_files(emit_indices)
	gen.merge_pass5_worker(worker)
	gen.gen_pass5_post()
	return gen.gen_finalize()
}

fn test_generate_c_hoists_if_expr_temp_before_result_propagation_call() {
	csrc := generate_result_option_c_for_test('
struct Params {
	checksum bool
}

struct Ctx {}

fn (mut c Ctx) set(v int) ! {
}

fn new_ctx(params Params) !Ctx {
	mut c := Ctx{}
	c.set(if params.checksum { 1 } else { 0 })!
	return c
}
')
	if_pos := csrc.index('int _if_t') or { panic('missing if-expression temp') }
	or_pos := csrc.index('_result_void _or_t') or { panic('missing result propagation temp') }
	assert if_pos < or_pos
	assert csrc.contains('Ctx__set(&c, _if_t')
}

fn test_generate_c_keeps_option_wrapper_for_fn_value_if_guard() {
	csrc := generate_result_option_c_for_test("
fn with_name_to_index(name_to_index fn (string) ?int) {
	if index := name_to_index('foo') {
		_ = index
	}
}
")
	assert csrc.contains('_option_int _or_t')
	assert csrc.contains('if ((_or_t')
	assert !csrc.contains('void* _or_t')
}

fn test_generate_c_keeps_option_wrapper_for_or_block_temp() {
	csrc := generate_result_option_c_for_test('
fn maybe_index() ?int {
	return 3
}

fn find_stop() int {
	stop_index := maybe_index() or { -1 }
	return stop_index
}
')
	assert csrc.contains('_option_int _or_t')
	assert csrc.contains('stop_index')
}

fn test_generate_c_ignores_direct_option_or_expr_stmt_payload() {
	csrc := generate_result_option_c_for_test('
struct User {}

fn maybe_user() ?User {
	return User{}
}

fn main() {
	maybe_user() or {}
}
')
	assert csrc.contains('_option_User _or_t')
	assert csrc.contains('.state != 0')
	assert !csrc.contains('User*)(((u8*)(&_or_t')
}

fn test_generate_c_preserves_string_slice_type_for_followup_index_or() {
	csrc := generate_result_option_c_for_test('
fn (s string) find_text(needle string) ?int {
	_ = s
	_ = needle
	return 0
}

fn find_symbol(sframe string) int {
	symbol_start := sframe.find_text("0x") or { -1 }
	rest := sframe[symbol_start..]
	space_after_addr := rest.find_text(" ") or { -1 }
	symbol_and_offset := rest[space_after_addr + 1..]
	plus_pos := symbol_and_offset.find_text(" + ") or { -1 }
	return plus_pos
}
	')
	assert csrc.contains('string symbol_and_offset = string__substr(rest')
	assert !csrc.contains('array symbol_and_offset = array__slice(rest')
	assert csrc.contains('.state != 0')
}

fn test_generate_c_declares_struct_result_or_value_with_struct_type() {
	csrc := generate_result_option_c_for_test('
struct Glob {}

fn new_glob() !Glob {
	return Glob{}
}

fn build() !Glob {
	glob := new_glob() or { return err }
	return glob
}
')
	assert csrc.contains('Glob glob =')
	assert !csrc.contains('int glob =')
}

fn test_generate_c_declares_static_method_result_or_value_with_struct_type() {
	csrc := generate_result_option_c_for_test('
struct Glob {}

fn Glob.new(pattern string) !Glob {
	_ = pattern
	return Glob{}
}

fn build() !Glob {
	glob := Glob.new("*.v") or { return err }
	return glob
}
')
	assert csrc.contains('Glob glob =')
	assert !csrc.contains('int glob =')
	assert !csrc.contains('Glob__new(Glob,')
}

fn test_generate_c_unwraps_module_result_or_inside_if_expr_branch() {
	csrc := generate_result_option_c_for_test_files([
		'
module codec

pub fn decompress(data []u8) ![]u8 {
	return data
}
',
		'
module main

import codec

fn decode(input []u8, flag bool) []u8 {
	mut decoded := input
	decoded = if flag {
		codec.decompress(decoded) or { return decoded }
	} else {
		decoded
	}
	return decoded
}
',
	])
	assert csrc.contains('_result_Array_u8 _or_t')
	assert csrc.contains('(*(Array_u8*)(((u8*)(&_or_t')
	assert !csrc.contains('int _if_expr_t')
}

fn test_generate_c_unwraps_result_or_in_nested_if_expr_branch() {
	csrc := generate_result_option_c_for_test_files([
		'
module codec

pub fn decompress(data []u8, check bool) ![]u8 {
	_ = check
	return data
}

pub fn inflate(data []u8) ![]u8 {
	return data
}
',
		'
module main

import codec

fn decode(input []u8, encoding string) []u8 {
	mut decoded := input
	decoded = if encoding == "gzip" || encoding == "x-gzip" {
		codec.decompress(decoded, true) or { return input }
	} else {
		if encoding == "deflate" {
			codec.inflate(decoded) or { return input }
		} else {
			decoded
		}
	}
	return decoded
}
',
	])
	assert csrc.count('_result_Array_u8 _or_t') >= 2
	assert csrc.contains('(*(Array_u8*)(((u8*)(&_or_t')
	assert !csrc.contains('= ({ int _if_expr_t')
}

fn test_generate_c_recovers_or_payload_when_final_expr_is_empty() {
	mut gen := Gen{
		sb:              strings.new_builder(256)
		fn_return_types: {
			'gzip__decompress': '_result_Array_u8'
		}
	}
	gen.gen_unsafe_expr(ast.UnsafeExpr{
		stmts: [
			ast.Stmt(ast.AssignStmt{
				op:  .decl_assign
				lhs: [ast.Expr(ast.Ident{
					name: '_or_t1'
				})]
				rhs: [
					ast.Expr(ast.CallExpr{
						lhs: ast.Ident{
							name: 'gzip__decompress'
						}
					}),
				]
			}),
			ast.Stmt(ast.ExprStmt{
				expr: ast.IfExpr{
					cond:  ast.SelectorExpr{
						lhs: ast.Ident{
							name: '_or_t1'
						}
						rhs: ast.Ident{
							name: 'is_error'
						}
					}
					stmts: []ast.Stmt{}
				}
			}),
			ast.Stmt(ast.ExprStmt{
				expr: ast.empty_expr
			}),
		]
	})
	csrc := gen.sb.str()
	assert csrc.contains('_result_Array_u8 _or_t1 = gzip__decompress();')
	assert csrc.contains('(*(Array_u8*)(((u8*)(&_or_t1.err)) + sizeof(IError)))')
}

fn test_generate_c_passes_mut_arg_by_address_to_fn_pointer_param() {
	csrc := generate_result_option_c_for_test('
fn render(replacement fn (string, mut []string)) int {
	mut out := []string{}
	replacement("x", mut out)
	return 0
}
')
	assert csrc.contains('replacement((string){.str = "x"')
	assert csrc.contains(', &out);')
	assert !csrc.contains(', out);')
}

fn test_generate_c_resolves_fn_literal_param_type_for_string_interpolation() {
	csrc := generate_result_option_c_for_test('
fn render(replacement fn (string, mut []string)) {
	mut out := []string{}
	replacement("x", mut out)
}

fn demo() {
	render(fn (name string, mut out []string) {
		out << "<\${name}>"
	})
}
')
	assert csrc.contains('"<%s>"')
	assert !csrc.contains('"<%d>"')
}

fn test_generate_c_resolves_selector_string_field_type_for_string_interpolation() {
	csrc := generate_result_option_c_for_test('
struct Alias {
	name        string
	description string
}

fn render(alias Alias) string {
	return "\${alias.name}:\\"\${alias.description}\\""
}
')
	assert csrc.contains('"%s:\\"%s\\""')
	assert !csrc.contains('"%d:\\"%d\\""')
}

fn test_generate_c_resolves_for_in_selector_string_field_type_for_string_interpolation() {
	csrc := generate_result_option_c_for_test('
struct Alias {
	name        string
	description string
}

fn aliases() []Alias {
	return [
		Alias{
			name: "vscode"
			description: "VS Code scheme (vscode://)"
		},
	]
}

fn render() string {
	mut last := ""
	for alias in aliases() {
		last = "    \${alias.name}:\\"\${alias.description}\\""
	}
	return last
}
')
	assert csrc.contains('"    %s:\\"%s\\""')
	assert !csrc.contains('"    %d:\\"%d\\""')
}

fn test_generate_c_expands_builtin_option_clone_if_guard() {
	csrc := generate_result_option_c_for_test('
interface IClone {}

struct Bag implements IClone {
	name ?string
}

fn copy_bag(b Bag) Bag {
	return b.clone()
}
	')
	assert csrc.contains('builtin__Option_string__clone')
	assert csrc.contains('.state == 0')
	assert !csrc.contains('if (s)')
	assert !csrc.contains('string _val = builtin__Option_string__clone')
}

fn test_generate_c_does_not_wrap_builtin_option_clone_for_multiple_option_fields() {
	csrc := generate_result_option_c_for_test('
interface IClone {}

struct Env implements IClone {
	host ?string
	prefix ?string
}

fn copy_env(e Env) Env {
	return e.clone()
}
	')
	assert csrc.contains('builtin__Option_string__clone')
	assert !csrc.contains('string _val = builtin__Option_string__clone')
}

fn test_generate_c_wraps_struct_field_option_value() {
	csrc := generate_result_option_c_for_test('
struct Ref {
	value int
}

struct Holder {
	item ?&Ref
}

fn make(r &Ref) Holder {
	return Holder{
		item: r
	}
}
')
	assert csrc.contains('_option_Refptr item;')
	assert csrc.contains('_option_Refptr _opt = (_option_Refptr){ .state = 2 }; Ref* _val = r; _option_ok(&_val, (_option*)&_opt, sizeof(_val)); _opt;')
	assert !csrc.contains('.item = r')
}

fn test_generate_c_wraps_module_lifetime_alias_value_for_option_field() {
	csrc := generate_result_option_c_for_test('
module sample

struct Item {}

type ItemRef[^a] = &^a Item

struct Holder[^a] {
	item ?ItemRef[^a]
}

fn make[^a](item ItemRef[^a]) Holder[^a] {
	return Holder[^a]{
		item: item
	}
}
')
	assert csrc.contains('_option_sample__ItemRef item;')
	assert csrc.contains('_option_sample__ItemRef _opt = (_option_sample__ItemRef){ .state = 2 }; sample__ItemRef _val = item; _option_ok(&_val, (_option*)&_opt, sizeof(_val)); _opt;')
	assert !csrc.contains('_option_ItemRef')
	assert !csrc.contains('.item = item')
}

fn test_generate_c_wraps_deref_value_for_option_string_field() {
	csrc := generate_result_option_c_for_test('
struct Holder {
	item ?string
}

struct Parser {
	glob &string
}

fn mk_error(p Parser) Holder {
	return Holder{
		item: *p.glob
	}
}
	')
	assert csrc.contains('_option_string item;')
	assert csrc.contains('_option_string _opt = (_option_string){ .state = 2 }; string _val = *')
	assert csrc.contains('glob; _option_ok(&_val, (_option*)&_opt, sizeof(_val)); _opt;')
	assert !csrc.contains('.item = *(p).glob')
}

fn test_generate_c_wraps_string_literal_for_option_string_field() {
	csrc := generate_result_option_c_for_test('
struct Holder {
	item ?string
}

fn mk_holder() Holder {
	return Holder{
		item: "--"
	}
}
')
	assert csrc.contains('_option_string item;')
	assert csrc.contains('_option_string _opt = (_option_string){ .state = 2 }; string _val = (string){.str = "--"')
	assert !csrc.contains('.item = (string){.str = "--"')
}

fn test_generate_c_interface_cast_strips_pointer_for_method_symbol() {
	csrc := generate_result_option_c_for_test('
interface Handle {
	len() int
}

struct File {}

fn (mut f File) len() int {
	_ = f
	return 1
}

fn consume(h &Handle) int {
	return h.len()
}

fn demo(mut file File) int {
	return consume(&file)
}
	')
	assert csrc.contains('.len = (int (*)(void*))File__len')
	assert !csrc.contains('File*__len')
}

fn test_generate_c_heap_boxes_addr_of_call_or_cast_interface() {
	csrc := generate_result_option_c_for_test('
interface Runner {
	next() int
}

struct Concrete {}

fn (mut c Concrete) next() int {
	return 7
}

fn make() &Runner {
	mut c := &Concrete{}
	return &Runner(c)
}

fn demo() int {
	r := make()
	return r.next()
}
')
	assert csrc.contains('Runner* _iface_t = (Runner*)malloc(sizeof(Runner))')
	assert csrc.contains('.next = (int (*)(void*))Concrete__next')
	assert !csrc.contains('return ((Runner*)(c));')
}

fn test_ierror_concrete_base_prefers_current_module_qualified_method() {
	mut env := types.Environment.new()
	env.set_expr_type(42, types.Type(types.Struct{
		name: 'TimeParseError'
	}))
	mut gen := Gen.new_with_env([], env)
	gen.cur_module = 'time'
	gen.fn_return_types['time__TimeParseError__msg'] = 'string'
	base := gen.ierror_concrete_base_for_expr(ast.Expr(ast.Ident{
		name: 'parse_err'
		pos:  token.Pos{
			id: 42
		}
	}))
	assert base == 'time__TimeParseError'
}

fn test_ierror_concrete_base_finds_qualified_method_outside_current_module() {
	mut env := types.Environment.new()
	env.set_expr_type(46, types.Type(types.Struct{
		name: 'TimeParseError'
	}))
	mut gen := Gen.new_with_env([], env)
	gen.cur_module = 'main'
	gen.fn_return_types['time__TimeParseError__msg'] = 'string'
	base := gen.ierror_concrete_base_for_expr(ast.Expr(ast.Ident{
		name: 'parse_err'
		pos:  token.Pos{
			id: 46
		}
	}))
	assert base == 'time__TimeParseError'
}

fn test_get_expr_type_prefers_explicit_module_qualified_init_expr_type() {
	mut env := types.Environment.new()
	env.set_expr_type(43, types.Type(types.Struct{
		name: 'TimeParseError'
	}))
	mut gen := Gen.new_with_env([], env)
	gen.cur_module = 'time'
	gen.emitted_types['body_time__TimeParseError'] = true
	expr := ast.Expr(ast.InitExpr{
		typ: ast.Ident{
			name: 'TimeParseError'
		}
		pos: token.Pos{
			id: 43
		}
	})
	assert gen.get_expr_type(expr) == 'time__TimeParseError'
}

fn test_get_expr_type_prefers_module_qualified_addr_of_init_expr_type() {
	mut env := types.Environment.new()
	env.set_expr_type(44, types.Type(types.Pointer{
		base_type: types.Struct{
			name: 'TimeParseError'
		}
	}))
	mut gen := Gen.new_with_env([], env)
	gen.cur_module = 'time'
	gen.emitted_types['body_time__TimeParseError'] = true
	expr := ast.Expr(ast.PrefixExpr{
		op:   .amp
		expr: ast.InitExpr{
			typ: ast.Ident{
				name: 'TimeParseError'
			}
		}
		pos:  token.Pos{
			id: 44
		}
	})
	assert gen.get_expr_type(expr) == 'time__TimeParseError*'
}

fn test_interface_concrete_type_prefers_module_qualified_addr_of_init_expr_type() {
	mut env := types.Environment.new()
	env.set_expr_type(45, types.Type(types.Pointer{
		base_type: types.Struct{
			name: 'TimeParseError'
		}
	}))
	mut gen := Gen.new_with_env([], env)
	gen.cur_module = 'time'
	gen.emitted_types['body_time__TimeParseError'] = true
	expr := ast.Expr(ast.PrefixExpr{
		op:   .amp
		expr: ast.InitExpr{
			typ: ast.Ident{
				name: 'TimeParseError'
			}
		}
		pos:  token.Pos{
			id: 45
		}
	})
	assert gen.concrete_type_for_interface_value('IError', expr) == 'time__TimeParseError*'
}

fn test_interface_concrete_type_prefers_module_qualified_wrapped_addr_of_init_expr_type() {
	mut gen := Gen.new([])
	gen.cur_module = 'time'
	gen.emitted_types['body_time__TimeParseError'] = true
	expr := ast.Expr(ast.CastExpr{
		typ:  ast.Ident{
			name: 'IError'
		}
		expr: ast.ParenExpr{
			expr: ast.PrefixExpr{
				op:   .amp
				expr: ast.InitExpr{
					typ: ast.Ident{
						name: 'TimeParseError'
					}
				}
			}
		}
	})
	assert gen.concrete_type_for_interface_value('IError', expr) == 'time__TimeParseError*'
}

fn test_generate_c_initializes_omitted_option_struct_fields_to_none() {
	csrc := generate_result_option_c_for_test('
struct Holder {
	item ?int
	name string
}

fn make_named() Holder {
	return Holder{
		name: "x"
	}
}

fn make_empty() Holder {
	return Holder{}
}
	')
	assert csrc.contains('_option_int){ .state = 2 }')
	assert !csrc.contains('return ((Holder){0})')
}

fn test_generate_c_initializes_omitted_option_struct_payload_fields_to_none() {
	csrc := generate_result_option_c_for_test('
interface IClone {}

struct Item implements IClone {
	name string
}

struct Holder implements IClone {
	name string
	item ?Item
}

fn make_named() Holder {
	return Holder{
		name: "x"
	}
}

fn make_empty() Holder {
	return Holder{}
}
	')
	assert csrc.contains('struct _option_Item')
	assert csrc.contains('_option_Item){ .state = 2 }')
	assert !csrc.contains('.item = ((_option_Item){.state = 2,.name =')
}

fn test_generate_c_initializes_omitted_option_struct_field_in_named_literal_to_none() {
	csrc := generate_result_option_c_for_test('
module sample

interface IClone {}

struct Encoding implements IClone {
	label string
}

struct Config implements IClone {
	line_number bool
	encoding ?Encoding
	max_matches ?u64
}

fn make_config() Config {
	return Config{
		line_number: true
		max_matches: none
	}
}
	')
	assert csrc.contains('struct _option_sample__Encoding')
	assert csrc.contains('_option_sample__Encoding){ .state = 2 }')
	assert !csrc.contains('.encoding = ((_option_sample__Encoding){.state = 2,.label =')
}

fn test_generate_c_compares_struct_option_fields_fieldwise() {
	csrc := generate_result_option_c_for_test('
struct Mode {
	after ?usize
}

fn same(a Mode, b Mode) bool {
	return a == b
}
')
	assert csrc.contains('_cmp_l_')
	assert csrc.contains('.after.state == _cmp_r_')
	assert csrc.contains('.after.state != 0 ||')
	assert !csrc.contains('memcmp(&_cmp_l_')
}

fn test_generate_c_initializes_fixed_array_field_from_param_array() {
	csrc := generate_result_option_c_for_test('
struct Holder {
	bitmap [4]u32
}

fn make(bitmap [4]u32) Holder {
	return Holder{
		bitmap: bitmap
	}
}
')
	assert csrc.contains('.bitmap = {bitmap[0], bitmap[1], bitmap[2], bitmap[3]}')
	assert !csrc.contains('.bitmap = bitmap')
}

fn test_generate_c_initializes_fixed_array_field_from_local_array() {
	csrc := generate_result_option_c_for_test('
struct Holder {
	bitmap [4]u32
}

fn make() Holder {
	mut bitmap := [4]u32{}
	return Holder{
		bitmap: bitmap
	}
}
')
	assert csrc.contains('.bitmap = {bitmap[0], bitmap[1], bitmap[2], bitmap[3]}')
	assert !csrc.contains('.bitmap = bitmap')
}

fn test_generate_c_declares_specialized_generic_option_return() {
	csrc := generate_result_option_c_for_test('
module sample

struct Item {}

struct Match[T] {
	value T
	has_value bool
}

fn (m Match[T]) inner() ?T {
	if !m.has_value {
		return none
	}
	return m.value
}

fn use(m Match[Item]) bool {
	if value := m.inner() {
		_ = value
		return true
	}
	return false
}
	')
	assert csrc.contains('typedef struct _option_sample__Item _option_sample__Item;')
	assert csrc.contains('struct _option_sample__Item')
	assert csrc.contains('_option_sample__Item sample__Match_T_sample_Item__inner_T_sample_Item')
}

fn test_generate_c_expands_lifetime_generic_option_field_if_guard() {
	csrc := generate_result_option_c_for_test('
struct Searcher {}

struct Core[^s] {
	searcher &^s Searcher
mut:
	binary_byte_offset_ ?usize
	line_number ?u64
}

fn (core Core[^s]) binary_byte_offset[^s]() ?u64 {
	if offset := core.binary_byte_offset_ {
		return u64(offset)
	}
	return none
}

fn (mut core Core[^s]) detect_binary[^s]() bool {
	if _ := core.binary_byte_offset_ {
		return true
	}
	return false
}

fn (mut core Core[^s]) count_lines[^s]() {
	if line_number := core.line_number {
		core.line_number = line_number + 1
	}
}

fn use_it(searcher &Searcher) {
	mut core := Core{
		searcher: searcher
	}
	_ = core.binary_byte_offset()
	_ = core.detect_binary()
	core.count_lines()
}

fn main() {
	s := Searcher{}
	use_it(&s)
}
')
	assert csrc.contains('_option_usize _or_t')
	assert csrc.contains('usize offset = (*(usize*)')
	assert csrc.contains('u64 line_number = (*(u64*)')
	assert !csrc.contains('if (core.binary_byte_offset_)')
	assert !csrc.contains('if (core->binary_byte_offset_)')
	assert !csrc.contains('if (core->line_number)')
	assert !csrc.contains('u64 _val = ({ _option_u64')
}

fn test_generate_c_expands_result_unwrap_method_receiver_if_guard() {
	csrc := generate_result_option_c_for_test('
struct FallibleUsize {
	has_value bool
	value usize
}

fn FallibleUsize.some(value usize) FallibleUsize {
	return FallibleUsize{
		has_value: true
		value: value
	}
}

fn (opt FallibleUsize) get() ?usize {
	if !opt.has_value {
		return none
	}
	return opt.value
}

struct Core[^s] {
	marker &^s int
}

fn (mut core Core[^s]) shortest_match[^s]() !FallibleUsize {
	_ = core
	return FallibleUsize.some(1)
}

fn (mut core Core[^s]) use_it[^s]() !bool {
	if _ := core.shortest_match()!.get() {
		return true
	}
	return false
}

fn main() {
	x := 1
	mut core := Core{
		marker: &x
	}
	_ = core.use_it() or { false }
}
')
	assert csrc.contains('_result_FallibleUsize _or_t')
	assert csrc.contains('_option_usize _or_t')
	assert csrc.contains('FallibleUsize__get((*(FallibleUsize*)')
	assert !csrc.contains('array__get(((FallibleUsize)')
}

fn test_generate_c_uses_branch_local_type_for_if_expr_result() {
	csrc := generate_result_option_c_for_test('
struct Match {
	start_ usize
	end_ usize
}

fn Match.new(start usize, end usize) Match {
	return Match{
		start_: start
		end_: end
	}
}

fn (m Match) start() usize {
	return m.start_
}

fn (m Match) end() usize {
	return m.end_
}

fn (m Match) is_empty() bool {
	return m.start_ == m.end_
}

struct FallibleMatch {
	has_value bool
	value Match
}

fn (opt FallibleMatch) get() ?Match {
	if !opt.has_value {
		return none
	}
	return opt.value
}

fn use_it(maybe FallibleMatch) bool {
	invert_match := if line := maybe.get() {
		range := Match.new(0, line.start())
		range
	} else {
		range := Match.new(0, 10)
		range
	}
	return invert_match.is_empty()
}

fn main() {
	_ = use_it(FallibleMatch{})
}
')
	assert csrc.contains('Match invert_match = ({')
	assert !csrc.contains('int invert_match = ({')
	assert csrc.contains('Match__is_empty(invert_match)')
	assert !csrc.contains('int__is_empty(invert_match)')
}

fn test_generate_c_emits_c_struct_option_and_result_payload_wrappers() {
	csrc := generate_result_option_c_for_test('
struct C.Widget {
	x int
}

interface IError {}

fn optional_widget(w ?C.Widget) ?C.Widget {
	return none
}

fn result_widget() !C.Widget {
	return C.Widget{}
}
')
	assert csrc.contains('typedef struct _option_struct_Widget _option_struct_Widget;')
	assert csrc.contains('typedef struct _result_struct_Widget _result_struct_Widget;')
	assert csrc.contains('struct _option_struct_Widget { u8 state; IError err; u8 data[sizeof(struct Widget) > 1 ? sizeof(struct Widget) : 1]; };')
	assert csrc.contains('struct _result_struct_Widget { bool is_error; IError err; u8 data[sizeof(struct Widget) > 1 ? sizeof(struct Widget) : 1]; };')
	assert csrc.contains('struct Widget _val = ((struct Widget){0});')
	assert !csrc.contains('struct_Widget _val')
	assert !csrc.contains('sizeof(struct_Widget)')
}

fn test_generate_c_wraps_tuple_call_return_in_option_tuple_return() {
	csrc := generate_result_option_c_for_test('
fn decode() (string, string) {
	return "user", "pass"
}

fn credentials() ?(string, string) {
	return decode()
}
')
	assert csrc.contains('Tuple_string_string _val = decode();')
	assert !csrc.contains('.arg0 = decode()')
}

fn test_generate_c_emits_struct_str_function_when_interpolated() {
	csrc := generate_result_option_c_for_test('
struct Thing {
	x int
}

fn msg(t Thing) string {
	return "\${t}"
}
')
	assert csrc.contains('string Thing__str(Thing s)')
	assert csrc.contains('Thing__str(t).str')
}

fn test_generate_c_does_not_emit_unused_error_method_with_unwalked_str_dependency() {
	csrc := generate_markused_c_for_test('
struct Term {
	x int
}

struct MyError {
	term Term
}

fn (err MyError) msg() string {
	return "\${err.term}"
}

fn (err MyError) code() int {
	_ = err
	return 0
}

fn unused() ! {
	return MyError{}
}

fn test_unused_error() {
	assert true
}
	')
	assert !csrc.contains('string MyError__msg(MyError err)')
	assert !csrc.contains('Term__str((err).term)')
}

fn test_generate_c_does_not_force_emit_unused_interface_candidate_method_body() {
	csrc := generate_markused_c_for_test('
interface Describer {
	msg() string
}

struct Inner {
	text string
}

fn (inner Inner) str() string {
	return inner.text
}

struct ErrorLike {
	inner Inner
}

fn (err ErrorLike) msg() string {
	return err.inner.str()
}

fn main() {
	_ = 1
}
	')
	assert !csrc.contains('string ErrorLike__msg(ErrorLike err)')
	assert !csrc.contains('Inner__str((err).inner)')
}

fn test_generate_c_emits_used_struct_operator_method_body_with_markused() {
	csrc := generate_markused_c_for_test('
struct Stats {
	n int
}

fn (left Stats) + (right Stats) Stats {
	return Stats{
		n: left.n + right.n
	}
}

fn test_stats_plus() {
	left := Stats{
		n: 1
	}
	right := Stats{
		n: 2
	}
	sum := left + right
	assert sum.n == 3
}
')
	assert csrc.contains('Stats Stats__op_plus(Stats left, Stats right)')
	assert csrc.count('Stats__op_plus(') >= 2
}

fn test_generate_c_lowers_struct_operator_compound_assignment() {
	csrc := generate_markused_c_for_test('
struct Stats {
	n int
}

fn (left Stats) * (right Stats) Stats {
	return Stats{
		n: left.n * right.n
	}
}

fn test_stats_mul_assign() {
	mut y := Stats{
		n: 2
	}
	x := Stats{
		n: 3
	}
	y *= x
	assert y.n == 6
}
')
	assert csrc.contains('Stats Stats__op_mul(Stats left, Stats right)')
	assert csrc.contains('y = Stats__op_mul(y, x);')
	assert !csrc.contains('y *= x;')
}

fn test_generate_c_borrows_option_field_unwrap_payload_without_temp() {
	csrc := generate_result_option_c_for_test('
struct Holder {
	value ?string
}

fn (h &Holder) value_ref() ?&string {
	if h.value != none {
		return unsafe { &h.value? }
	}
	return none
}
	')
	assert !csrc.contains('.is_error')
	assert !csrc.contains('_or_t')
	assert csrc.contains('value.state != 0')
	assert csrc.contains('value.err)) + sizeof(IError)))')
}

fn test_generate_c_returns_custom_error_from_result_function_as_error() {
	csrc := generate_result_option_c_for_test('
struct SizeError {}

fn (err SizeError) msg() string {
	return "bad size"
}

fn (err SizeError) code() int {
	return 7
}

fn make_error() SizeError {
	return SizeError{}
}

fn parse() !u64 {
	return make_error()
}
	')
	assert csrc.contains('return (_result_u64){ .is_error=true, .err=')
	assert csrc.contains('IError_SizeError_msg_wrapper')
	assert csrc.contains('SizeError* _ierr_obj')
	assert !csrc.contains('u64 _val = main__make_error()')
}

fn test_generate_c_returns_ierror_local_from_result_function_as_error() {
	csrc := generate_result_option_c_for_test('
interface IError {
	msg() string
	code() int
}

struct MyError {}

fn (err MyError) msg() string {
	return "bad"
}

fn (err MyError) code() int {
	return 1
}

fn make_error() IError {
	return MyError{}
}

fn fail() !int {
	e := make_error()
	return e
}
	')
	assert csrc.contains('return (_result_int){ .is_error=true, .err=e };')
	assert !csrc.contains('int _val = e')
}

fn test_generate_c_returns_option_or_error_fallback_from_result_function_as_error() {
	csrc := generate_result_option_c_for_test('
interface IError {
	msg() string
}

struct MessageError {}

fn (err MessageError) msg() string {
	return "missing"
}

fn error(msg string) IError {
	return MessageError{}
}

struct Payload {
	value int
}

fn maybe_payload() ?Payload {
	return none
}

fn fail() !Payload {
	return maybe_payload() or { error("missing") }
}
	')
	assert csrc.contains('_option_Payload _or_t')
	assert csrc.contains('return (_result_Payload){ .is_error=true, .err=')
	assert !csrc.contains(' = main__error(')
}

fn test_generate_c_keeps_concrete_error_literal_when_context_is_concrete() {
	csrc := generate_result_option_c_for_test('
struct MyError {}

fn (err MyError) msg() string {
	return "bad"
}

fn (err MyError) code() int {
	return 1
}

fn main() {
	mut errors := []MyError{}
	err := MyError{}
	errors << err
}
	')
	assert csrc.contains('MyError err = ((MyError){')
	assert csrc.contains('array__push(((array*)(&errors)), &(MyError[1]){err});')
	assert !csrc.contains('IError err =')
	assert !csrc.contains('&(MyError[1]){((IError)')
}

fn test_generate_c_decl_assign_from_option_err_uses_ierror() {
	csrc := generate_result_option_c_for_test('
struct MyError {}

fn (err MyError) msg() string {
	return "bad"
}

fn (err MyError) code() int {
	return 1
}

fn maybe_value() ?int {
	return MyError{}
}

fn main() {
	_ := maybe_value() or {
		err := err
		_ = err
		return
	}
}
	')
	assert csrc.contains('IError err = _or_t')
	assert !csrc.contains('MyError err = _or_t')
}

fn test_generate_c_keeps_option_if_guard_err_as_concrete_error_ref() {
	csrc := generate_result_option_c_for_test('
struct MyError {}

fn (err MyError) msg() string {
	return "bad"
}

fn maybe_error() ?&MyError {
	return &MyError{}
}

fn read() string {
	if err := maybe_error() {
		return err.msg()
	}
	return ""
}
	')
	assert csrc.contains('MyError__msg((*err))')
	assert !csrc.contains('err->_object')
	assert !csrc.contains('MyError__msg((*err),')
}

fn test_generate_c_casts_concrete_arg_for_mut_interface_param() {
	csrc := generate_result_option_c_for_test('
interface Reader {
mut:
	read(mut []u8) !int
}

struct ByteReader {}

fn (mut rdr ByteReader) read(mut buf []u8) !int {
	return 0
}

fn consume(mut rdr Reader) !int {
	mut buf := []u8{len: 4}
	return rdr.read(mut buf)
}

fn demo() !int {
	mut rdr := ByteReader{}
	return consume(mut rdr)
}
	')
	assert csrc.contains('Reader* _iface_t')
	assert csrc.contains('ByteReader__read')
	assert !csrc.contains('consume(&rdr)')
}

fn test_generate_c_unwraps_interface_method_result_payload_for_propagation() {
	csrc := generate_result_option_c_for_test('
interface Reader {
mut:
	read(mut []u8) !int
}

fn read_full(mut reader Reader, mut buf []u8) ! {
	mut offset := 0
	for offset < buf.len {
		n := reader.read(mut buf[offset..])!
		offset += n
	}
}
	')
	assert csrc.contains('_result_int _or_t')
	assert csrc.contains('int n = (*(int*)')
	assert !csrc.contains('int n = ;')
}

fn test_generate_c_unwraps_generic_comptime_interface_method_result_payload() {
	csrc := generate_result_option_c_for_test_files([
		'
module core

import printer

struct BufferWriter implements printer.WriteColor {}

fn (mut w BufferWriter) write(buf []u8) !int {
	_ = w
	return buf.len
}

fn demo() !int {
	mut standard := printer.Standard.new(BufferWriter{})
	return standard.write([]u8{})
}
',
		'
module printer

pub interface WriteColor {
mut:
	write([]u8) !int
}

pub struct CounterWriter[W] {
mut:
	wtr W
}

pub fn CounterWriter.new[W](wtr W) CounterWriter[W] {
	return CounterWriter[W]{
		wtr: wtr
	}
}

pub fn (mut w CounterWriter[W]) write(buf []u8) !int {
	$if W is WriteColor {
		n := w.wtr.write(buf)!
		return n
	} $else {
		_ = buf
		return 0
	}
}

pub struct Standard[W] {
mut:
	wtr CounterWriter[W]
}

pub fn Standard.new[W](wtr W) Standard[W] {
	return Standard[W]{
		wtr: CounterWriter.new(wtr)
	}
}

pub fn (mut s Standard[W]) write(buf []u8) !int {
	return s.wtr.write(buf)
}
	',
	])
	assert csrc.contains('_result_int printer__CounterWriter_T_core_BufferWriter__write_T_core_BufferWriter')
	assert csrc.contains('core__BufferWriter__write(&w->wtr, buf)')
	assert csrc.contains('int n = (*(int*)')
	assert !csrc.contains('int n = ;')
}

fn test_generate_c_preserves_static_lifetime_constructor_and_interface_pointer_field() {
	csrc := generate_result_option_c_for_test('
interface Reader {
mut:
	read(mut []u8) !int
}

struct ByteReader {}

fn (mut rdr ByteReader) read(mut buf []u8) !int {
	return 0
}

struct Config {}

struct TranscodingReader[^r] {
mut:
	rdr &^r Reader
	config Config
}

fn TranscodingReader.new[^r](rdr &^r Reader, config Config) TranscodingReader[^r] {
	return TranscodingReader[^r]{
		rdr: rdr
		config: config
	}
}

fn (mut rdr TranscodingReader[^r]) read[^r](mut buf []u8) !int {
	return rdr.rdr.read(mut buf)
}

struct LineBuffer {}

struct LineBufferReader[^r, ^b] {
mut:
	rdr &^r Reader
	buf &^b LineBuffer
}

fn LineBufferReader.new[^r, ^b](rdr &^r Reader, buf &^b LineBuffer) LineBufferReader[^r, ^b] {
	return LineBufferReader[^r, ^b]{
		rdr: rdr
		buf: buf
	}
}

fn use_it(mut read_from Reader, config Config, buf &LineBuffer) ! {
	mut decoded := TranscodingReader.new(&read_from, config)
	mut rdr := LineBufferReader.new(&decoded, buf)
	_ = rdr
}
	')
	assert csrc.contains('return ((TranscodingReader){.rdr = rdr,.config = config})')
	assert csrc.contains('return ((LineBufferReader){.rdr = rdr,.buf = buf})')
	assert csrc.contains('LineBufferReader rdr = LineBufferReader__new(')
	assert !csrc.contains('TranscodingReader rdr = TranscodingReader__new')
	assert !csrc.contains('Config__read')
	assert !csrc.contains('LineBuffer__read')
}

fn test_generate_c_preserves_c_pointer_cast_selector_field_access() {
	csrc := generate_result_option_c_for_test('
@[typedef]
struct C.log__Logger {
mut:
	_object voidptr
}

interface Logger {
mut:
	free()
}

fn raw_object(logger &Logger) voidptr {
	unsafe {
		pobject := &C.log__Logger(logger)._object
		return pobject
	}
}
	')
	assert csrc.contains('pobject = ((log__Logger*)(logger))->_object;')
	assert !csrc.contains('voidptr* pobject')
	assert !csrc.contains('&logger->_object')
}

fn test_generate_c_preserves_embedded_error_concrete_type_name() {
	csrc := generate_result_option_c_for_test('
struct Error {}

fn (err Error) msg() string {
	return ""
}

fn (err Error) code() int {
	return 0
}

struct Eof {
	Error
}

fn read() !int {
	return Eof{}
}

fn demo() bool {
	_ := read() or {
		return err is Eof
	}
	return false
}
	')
	assert csrc.contains('IError_Eof_type_name_wrapper')
	assert csrc.contains('IError_Eof_msg_wrapper')
	assert !csrc.contains('.type_name = IError_Error_type_name_wrapper')
}

fn test_generate_c_does_not_emit_nested_generic_structs_with_placeholder_args() {
	csrc := generate_result_option_c_for_test('
struct NoColor[W] {
mut:
	wtr W
}

struct CounterWriter[W] {
mut:
	wtr W
}

struct Summary[W] {
mut:
	wtr CounterWriter[W]
}

fn build_no_color[W](wtr W) Summary[NoColor[W]] {
	_ = wtr
	return Summary[NoColor[W]]{}
}
')
	assert !csrc.contains('struct CounterWriter {\n\tNoColor wtr;')
	assert !csrc.contains('struct Summary {\n\tCounterWriter wtr;')
}

fn test_generate_c_orders_nested_generic_struct_dependencies() {
	csrc := generate_result_option_c_for_test('
struct PlainWriter {}

struct NoColor[W] {
mut:
	wtr W
}

struct CounterWriter[W] {
mut:
	wtr W
}

struct Direct[W] {
mut:
	wtr CounterWriter[W]
}

struct JSON[W] {
mut:
	wtr CounterWriter[NoColor[W]]
}

fn build_direct[W](wtr W) Direct[W] {
	_ = wtr
	return Direct[W]{}
}

fn build[W](wtr W) JSON[W] {
	_ = wtr
	return JSON[W]{}
}

fn demo() {
	_ := build_direct(PlainWriter{})
	_ := build(PlainWriter{})
}
	')
	dep_pos := csrc.index('struct CounterWriter_T_NoColor_T_PlainWriter {') or {
		panic('missing concrete nested generic struct body')
	}
	user_pos := csrc.index('struct JSON_T_PlainWriter {') or {
		panic('missing generic user struct body')
	}
	assert dep_pos < user_pos
}

fn test_generate_c_preserves_primitive_generic_struct_binding() {
	csrc := generate_result_option_c_for_test('
struct Box[T] {
	value T
}

fn make() Box[int] {
	return Box[int]{
		value: 1
	}
}

fn main() {
	box := make()
	_ = box.value
}
')
	assert csrc.contains('struct Box {\n\tint value;')
	assert csrc.contains('Box make()')
	assert !csrc.contains('f64 make()')
	assert !csrc.contains('f64 box = make()')
}

fn test_generate_c_preserves_nested_primitive_generic_struct_binding() {
	csrc := generate_result_option_c_for_test('
struct Inner[T] {
	value T
}

struct Outer[T] {
	inner Inner[T]
}

fn make() Outer[int] {
	return Outer[int]{
		inner: Inner[int]{
			value: 1
		}
	}
}

fn main() {
	outer := make()
	_ = outer.inner.value
}
	')
	assert csrc.contains('struct Inner {\n\tint value;')
	assert csrc.contains('struct Outer {\n\tInner inner;')
		|| csrc.contains('struct Outer {\n\tInner_T_int inner;')
	assert csrc.contains('Outer make()')
	assert !csrc.contains('f64 make()')
	assert !csrc.contains('f64 outer = make()')
	assert !csrc.contains('((f64){.inner = ((f64){.value = 1})})')
}

fn test_generate_c_skips_interface_clone_for_incomplete_generic_implementor() {
	csrc := generate_result_option_c_for_test('
interface Writer {
mut:
	write() !int
}

struct Wrapper[W] {
mut:
	wtr W
}

fn (mut w Wrapper[W]) write() !int {
	_ = w
	return 0
}

fn wrap[W](wtr W) Wrapper[W] {
	return Wrapper[W]{
		wtr: wtr
	}
}
')
	assert !csrc.contains('sizeof(Wrapper)')
	assert !csrc.contains('Wrapper__write(Wrapper* w) {')
}

fn test_generate_c_names_generic_sum_type_variant_fields_from_base_type() {
	csrc := generate_result_option_c_for_test('
struct A[T] {
	x T
}

struct B[T] {
	x T
}

type P = A[int] | B[int]

fn make() P {
	return P(A[int]{
		x: 1
	})
}
')
	assert csrc.contains('void* _A;')
	assert csrc.contains('void* _B;')
	assert csrc.contains('._data._A =')
	assert !csrc.contains('void* _v0;')
	assert !csrc.contains('._data._v0 =')
}

fn test_generate_c_does_not_rewrap_explicit_sumtype_cast_in_result_return() {
	csrc := generate_result_option_c_for_test('
struct Null {}

type Primitive = Null | bool | []Primitive

fn make() !Primitive {
	return Primitive(true)
}
')
	assert csrc.contains('Primitive _val = ((Primitive){._tag = 1, ._data._bool')
	assert !csrc.contains('Primitive _val = ((Primitive){._tag = 2,._data._Array_Primitive')
}

fn test_generate_c_uses_qualified_ierror_wrapper_for_module_error() {
	csrc := generate_result_option_c_for_test('
module sample

struct ParseError {}

fn (err ParseError) msg() string {
	return ""
}

fn (err ParseError) code() int {
	return 0
}

fn read() !int {
	return ParseError{}
}
')
	assert csrc.contains('IError_sample__ParseError_msg_wrapper')
	assert !csrc.contains('IError_ParseError_msg_wrapper')
}

fn test_generate_c_uses_qualified_ierror_wrapper_for_module_ierror_return() {
	csrc := generate_result_option_c_for_test('
module sample

interface IError {
	msg() string
}

struct ParseError {}

fn (err ParseError) msg() string {
	return ""
}

fn parse_error() IError {
	return ParseError{}
}
')
	assert csrc.contains('.msg = IError_sample__ParseError_msg_wrapper')
	assert !csrc.contains('.msg = IError_ParseError_msg_wrapper')
}

fn test_sum_type_variant_field_name_preserves_module_qualified_variant() {
	mut gen := Gen.new([])
	gen.sum_type_variants['ast__Stmt'] = ['ast__FnDecl', 'ast__EmptyStmt']
	assert gen.sum_type_variant_field_name('ast__Stmt', 'FnDecl') == 'ast__FnDecl'
	assert gen.sum_type_variant_field_name('ast__Stmt', 'ast__FnDecl') == 'ast__FnDecl'
	gen.sum_type_variants['json2__Any'] = ['Array_json2__Any', 'Map_string_json2__Any']
	assert gen.sum_type_variant_field_name('json2__Any', 'Array_json2__Any') == 'Array_json2__Any'
	assert gen.sum_type_variant_field_name('json2__Any', 'Map_string_json2__Any') == 'Map_string_json2__Any'
	assert gen.sum_type_variant_field_name('json2__Any', 'Map_string_Any') == 'Map_string_json2__Any'
	gen.sum_type_variants['ast__Type'] = ['ast__FnType']
	assert gen.sum_type_variant_field_name('ast__Type', 'types__FnType') == 'types__FnType'
	if _ := gen.sum_variant_tag_path('ast__Type', 'types__FnType', []string{}) {
		assert false
	} else {
		assert true
	}
}

fn test_sum_data_variant_selector_field_preserves_module_qualified_variant() {
	mut gen := Gen.new([])
	gen.sum_type_variants['ast__Stmt'] = ['ast__FnDecl', 'ast__EmptyStmt']
	gen.remember_runtime_local_type('stmt', 'ast__Stmt')
	sel := ast.SelectorExpr{
		lhs: ast.SelectorExpr{
			lhs: ast.Ident{
				name: 'stmt'
			}
			rhs: ast.Ident{
				name: '_data'
			}
		}
		rhs: ast.Ident{
			name: '_FnDecl'
		}
	}
	assert gen.sum_data_variant_selector_field(sel) or { '' } == '_ast__FnDecl'
}

fn test_sum_narrowed_selector_uses_payload_base_type_for_pointer_env_type() {
	mut env := types.Environment.new()
	env.set_expr_type(51, types.Type(types.Pointer{
		base_type: types.Struct{
			name: 'ast__Ident'
		}
	}))
	mut gen := Gen.new_with_env([], env)
	gen.sum_type_variants['ast__Expr'] = ['ast__Ident']
	gen.remember_runtime_local_type('rhs', 'ast__Expr')
	gen.expr(ast.Expr(ast.SelectorExpr{
		lhs: ast.Ident{
			name: 'rhs'
			pos:  token.Pos{
				id: 51
			}
		}
		rhs: ast.Ident{
			name: 'name'
		}
	}))
	out := gen.sb.str()
	assert out.contains('((ast__Ident*)')
	assert !out.contains('ast__Ident**')
}

fn test_sum_cast_keeps_selector_with_declared_sum_field_type() {
	mut env := types.Environment.new()
	env.set_expr_type(62, types.Type(types.Struct{
		name: 'ast__SelectorExpr'
	}))
	mut gen := Gen.new_with_env([], env)
	gen.sum_type_variants['ast__Expr'] = ['ast__Ident', 'ast__SelectorExpr']
	gen.struct_field_types['ast__CallExpr.lhs'] = 'ast__Expr'
	gen.remember_runtime_local_type('expr', 'ast__CallExpr')
	sel := ast.Expr(ast.SelectorExpr{
		lhs: ast.Ident{
			name: 'expr'
		}
		rhs: ast.Ident{
			name: 'lhs'
		}
		pos: token.Pos{
			id: 62
		}
	})
	gen.gen_type_cast_expr('ast__Expr', sel)
	assert gen.sb.str() == 'expr.lhs'
}

fn test_generate_c_uses_payload_base_type_for_smartcast_map_key_selector() {
	csrc := generate_result_option_c_for_test('
struct Ident {
	name string
}

struct SelectorExpr {
	lhs Expr
}

type Expr = Ident | SelectorExpr

fn lookup(mut const_types map[string]string, rhs Expr) {
	if rhs is Ident {
		if ct := const_types[rhs.name] {
			_ = ct
		}
	}
}
')
	assert csrc.contains('map__get_check')
	assert !csrc.contains('Ident**')
}

fn test_generate_c_uses_nested_sum_smartcast_for_selector_field_methods() {
	csrc := generate_result_option_c_for_test('
struct BasicLiteral {
	kind  int
	value string
}

struct SelectorExpr {
	pos Pos
}

struct Pos {
	id int
}

fn (p Pos) is_valid() bool {
	return p.id > 0
}

type Expr = BasicLiteral | SelectorExpr

struct Field {
	value Expr
}

fn is_float_field(field Field) bool {
	return field.value is BasicLiteral && field.value.kind == 1
		&& field.value.value.contains(".")
}

fn has_valid_pos(expr Expr) bool {
	if expr is SelectorExpr {
		return expr.pos.is_valid()
	}
	return false
}
')
	assert csrc.contains('string__contains(')
	assert !csrc.contains('int__contains(')
	assert !csrc.contains('field.value.value')
	assert csrc.contains('Pos__is_valid(')
	assert !csrc.contains('int__is_valid(')
}

fn test_generate_c_keeps_declared_sum_selector_field_cast_identity() {
	csrc := generate_result_option_c_for_test('
struct Ident {
	name string
}

struct SelectorExpr {
	lhs Expr
}

struct EmptyExpr {}

struct CallExpr {
	lhs Expr
}

type Expr = EmptyExpr | Ident | SelectorExpr

fn keep_lhs(expr CallExpr) Expr {
	if expr.lhs is SelectorExpr {
		return Expr(expr.lhs)
	}
	return Expr(EmptyExpr{})
}
')
	assert !csrc.contains('= expr.lhs; memdup')
}

fn test_generate_c_passes_declared_sum_selector_field_arg_without_rewrap() {
	csrc := generate_result_option_c_for_test('
struct Ident {
	name string
}

struct SelectorExpr {
	lhs Expr
}

struct EmptyExpr {}

struct CallExpr {
	lhs Expr
}

type Expr = EmptyExpr | Ident | SelectorExpr

fn use_expr(arg Expr) {
	_ = arg
}

fn keep_lhs(expr CallExpr) {
	if expr.lhs is SelectorExpr {
		use_expr(expr.lhs)
	}
}
')
	assert !csrc.contains('= expr.lhs; memdup')
}

fn test_generate_c_initializes_fixed_array_struct_field_from_literal() {
	csrc := generate_result_option_c_for_test('
struct Process {
	stdio_fd [3]int
}

fn new_process() &Process {
	return &Process{
		stdio_fd: [-1, -1, -1]!
	}
}
')
	assert csrc.contains('.stdio_fd = {-1, -1, -1}')
	assert !csrc.contains('{{-1, -1, -1}[0]')
}

fn test_generate_c_renames_builtin_panic_call() {
	csrc := generate_result_option_c_for_test('
fn panic(s string) {
	_ = s
}

fn main() {
	panic("x")
}
')
	assert csrc.contains('v_panic((string){.str = "x"')
	assert !csrc.contains('\tpanic((string){.str = "x"')
}

fn test_generate_c_panics_for_bang_in_non_result_main() {
	csrc := generate_result_option_c_for_test('
struct App {}

fn new_app() !&App {
	return &App{}
}

fn main() {
	mut app := new_app()!
	_ = app
}
')
	assert csrc.contains('v_panic(IError__str(err));')
	assert !csrc.contains('return err;')
}

fn test_generate_c_returns_none_for_result_or_none_in_option_return() {
	csrc := generate_result_option_c_for_test('
fn find_path() !string {
	return "git"
}

fn get_path() ?string {
	return find_path() or { none }
}
')
	assert csrc.contains('return (_option_string){ .state = 2 };')
	assert !csrc.contains('/* [TODO] Type */ 0')
}

fn test_generate_c_lowers_sql_create_table_to_orm_driver_call() {
	csrc := generate_result_option_c_for_test_files([
		'
import orm

struct DB {}

fn (db DB) create(table orm.Table, fields []orm.TableField) ! {}

enum RepoStatus {
	open
	closed
}

struct Repo {
	id      int    @[primary; sql: serial]
	name    string @[unique: "repo"]
	status  RepoStatus
	skip_me string @[skip]
}

fn create(mut db DB) ! {
	sql db {
		create table Repo
	}!
}
',
		'
module orm

pub const enum_ = -3
pub const type_string = 20
pub const type_idx = {
	"int": 7
}

pub struct Table {}

pub struct TableField {}
',
	])
	assert csrc.contains('DB__create(')
	assert csrc.contains('orm__Table')
	assert csrc.contains('orm__TableField')
	assert csrc.contains('"repo"')
	assert csrc.contains('"id"')
	assert csrc.contains('"primary"')
	assert csrc.contains('"sql"')
	assert csrc.contains('"serial"')
	assert csrc.contains('"unique"')
	assert csrc.contains('.typ = 7')
	assert csrc.contains('.typ = -3')
	assert !csrc.contains('"skip_me"')
	assert !csrc.contains('((_result_void){0})')
	assert !csrc.contains('/* [TODO] SqlExpr */ 0')
}

fn test_generate_c_sql_or_array_placeholder_has_no_result_probe() {
	csrc := generate_result_option_c_for_test('
struct DB {}
struct TwoFactor {}

fn load(mut db DB) []TwoFactor {
	rows := sql db {
		select from TwoFactor
	} or {
		[]TwoFactor{}
	}
	return rows
}
')
	assert csrc.contains('Array_TwoFactor rows = ((Array_TwoFactor){0});')
	assert !csrc.contains('Array_TwoFactor _or_t')
	assert !csrc.contains('.is_error')
}