C declarations imported from an external module cannot be used for casting

[revosw]

Describe the bug

When a C type declaration is declared in the same module as you are running with v run ., you may cast a value to that C type. However, when the same type is declared in an external module and you import that module, you get

main.v:5:15: error: unknown function: C.TEST
    3 |
    4 | fn main() {
    5 |     println(C.TEST(0))
      |               ~~~~~~~
    6 | }
main.v:5:5: error: `println` can not print void expressions
    3 |
    4 | fn main() {
    5 |     println(C.TEST(0))
      |     ~~~~~~~~~~~~~~~~~~
    6 | }

Reproduction Steps

Initialize a brand new project with v init
Create a new main.c.v file with the contents:

module main

type C.TEST = int

Now edit main.v to use the type

module main

fn main() {
    println(C.TEST(0))
}

Notice that this works exactly as intended.

Now create a new folder ./mymodule and v init inside. Then move main.c.v from the parent module to mymodule, rename it to mod.c.v and replace the contents with:

module mymodule

pub type C.TEST = int

Rename mymodule/main.v to mymodule/mod.v, then change mymodule/mod.v to only contain

module mymodule

Expected Behavior

Instead of an error saying "unknown function", casting should just work like locally declared C types

Current Behavior

Compilation fails with error

main.v:5:15: error: unknown function: C.TEST
    3 |
    4 | fn main() {
    5 |     println(C.TEST(0))
      |               ~~~~~~~
    6 | }
main.v:5:5: error: `println` can not print void expressions
    3 |
    4 | fn main() {
    5 |     println(C.TEST(0))
      |     ~~~~~~~~~~~~~~~~~~
    6 | }

Possible Solution

No response

Additional Information/Context

No response

V version

V 0.4.12 21a0f11

Environment details (OS name and version, etc.)

V full version	V 0.4.12 cd035e2.21a0f11
OS	windows, Microsoft Windows 11 Pro 22000 64-bit
Processor	4 cpus, 64bit, little endian, Intel(R) Core(TM) i5-6200U CPU @ 2.30GHz
Memory	2.88GB/7.41GB
V executable	C:\dev_tools\v\v.exe
V last modified time	2025-12-28 12:49:02
V home dir	OK, value: C:\dev_tools\v
VMODULES	OK, value: C:\Users\bruker.vmodules
VTMP	OK, value: C:\Users\bruker\AppData\Local\Temp\v_0
Current working dir	OK, value: C:\dev\v\trash\ccast
Git version	git version 2.36.1.windows.1
V git status	weekly.2023.52-4284-g21a0f111
.git/config present	true
cc version	N/A
gcc version	N/A
clang version	N/A
msvc version	N/A
tcc version	tcc version 0.9.27 (x86_64 Windows)
tcc git status	thirdparty-windows-amd64 b425ac82
emcc version	N/A
glibc version	N/A

Note

You can use the 👍 reaction to increase the issue's priority for developers.

Please note that only the 👍 reaction to the issue itself counts as a vote.
Other reactions and those to comments will not be taken into account.

[revosw]

Note

I'm using this message as a temporary place for notes. It will be adjusted over time as I continue working on this issue.

The entry point of the compiler is vlib/v/v.v

https://github.com/vlang/v/blob/master/cmd/v/v.v#L75

With no arguments (v .), rebuild() is called

v/cmd/v/v.v

Lines 166 to 173 in 2e983cf

	else {
	if command.ends_with('.v') || os.exists(command) {
	// println('command')
	// println(prefs.path)
	rebuild(prefs)
	return
	}
	}

rebuild in turn calls the compile() function from the v.builder module. The compile function
itself isn't that interesting for this issue, we're only interested in the cbuilder.compile_c callback passed in

v/cmd/v/v.v

Lines 204 to 213 in 2e983cf

	.c {
	$if no_bootstrapv ? {
	// TODO: improve the bootstrapping with a split C backend here.
	// C code generated by `VEXE=v cmd/tools/builders/c_builder -os cross -o c.c cmd/tools/builders/c_builder.v`
	// is enough to bootstrap the C backend, and thus the rest, but currently bootstrapping relies on
	// `v -os cross -o v.c cmd/v` having a functional C codegen inside instead.
	util.launch_tool(prefs.is_verbose, 'builders/c_builder', os.args[1..])
	}
	builder.compile('build', prefs, cbuilder.compile_c)
	}

compile_c collects all the built-in .v files and user .v files, and passes them to build_c.

v/vlib/v/builder/cbuilder/cbuilder.v

Lines 39 to 50 in 2e983cf

	mut files := b.get_builtin_files()
	files << b.get_user_files()
	b.set_module_lookup_paths()
	if b.pref.is_verbose {
	println('all .v files:')
	println(files)
	}
	mut out_name_c := b.get_vtmp_filename(b.pref.out_name, '.tmp.c')
	if b.pref.is_shared {
	out_name_c = b.get_vtmp_filename(b.pref.out_name, '.tmp.so.c')
	}
	build_c(mut b, files, out_name_c)

build_c sets the output .c file path, then calls gen_c which internally runs the front and middle stages of the compiler

v/vlib/v/builder/cbuilder/cbuilder.v

Lines 71 to 80 in 2e983cf

	pub fn gen_c(mut b builder.Builder, v_files []string) strings.Builder {
	b.front_and_middle_stages(v_files) or {
	if err.code() > 7000 {
	return []u8{}
	}
	builder.verror(err.msg())
	}
	util.timing_start('C GEN')
	result := c.gen(b.parsed_files, mut b.table, b.pref)

The problem happens during checking, not during the actual writing of the .c file, which means we need to dive into front_and_middle_stages.

The front stage is only considering the steps leading up to checking - reading all v_files into memory, then scanning, tokenizing and parsing. The middle stage is where the checking happens.

The error happens during checking, so we dive into the check_files method on the checker

v/vlib/v/builder/builder.v

Lines 128 to 135 in 2e983cf

	pub fn (mut b Builder) middle_stages() ! {
	util.timing_start('CHECK')
	util.timing_start('Checker.generic_insts_to_concrete')
	b.table.generic_insts_to_concrete()
	util.timing_measure('Checker.generic_insts_to_concrete')
	b.checker.check_files(b.parsed_files)

check_files calls check for each file

v/vlib/v/checker/checker.v

Lines 384 to 412 in 2e983cf

	pub fn (mut c Checker) check_files(ast_files []&ast.File) {
	// println('check_files')
	// c.files = ast_files
	mut has_main_mod_file := false
	mut has_no_main_mod_file := false
	mut has_main_fn := false
	// Determine the project directory when using -line-info
	mut project_dir := ''
	if c.pref.is_vls && c.pref.line_info != '' {
	project_dir = if os.is_dir(c.pref.path) {
	os.real_path(c.pref.path)
	} else {
	os.real_path(os.dir(c.pref.linfo.path))
	}
	}
	unsafe {
	mut files_from_main_module := []&ast.File{}
	for i in 0 .. ast_files.len {
	mut file := ast_files[i]
	if c.pref.is_vls && c.pref.line_info == '' && file.path != c.pref.path {
	continue
	}
	if c.pref.is_vls && c.pref.line_info != '' && project_dir != '' {
	if !os.real_path(file.path).starts_with(project_dir) {
	continue
	}
	}
	c.timers.start('checker_check ${file.path}')
	c.check(mut file)

The checker is run in sequence on every file, and the checker state is reset when checking a new file.

Now it's time to see what we are working with. The ast for mymodule/mod.c.v is:

ast.File{
    nr_lines: 2
    nr_bytes: 40
    nr_tokens: 10
    mod: ast.Module{
        name: 'mymodule'
        short_name: 'mymodule'       
        attrs: []
        pos: token.Pos{
            len: 15
            line_nr: 0
            pos: 0
            col: 0
            file_idx: 63
            last_line: 0
        }
        name_pos: token.Pos{
            len: 8
            line_nr: 0
            pos: 7
            col: 7
            file_idx: 63
            last_line: 0
        }
        is_skipped: false
    }
    global_scope: &# 0 - 0
  * const: symopt_undname - ast.Type(0x0 = 0)
  * const: symopt_deferred_loads - ast.Type(0x0 = 0)
  * const: symopt_no_cpp - ast.Type(0x0 = 0)
  * const: symopt_load_lines - ast.Type(0x0 = 0)
  * const: symopt_include_32bit_modules - ast.Type(0x0 = 0)
  * const: symopt_allow_zero_address - ast.Type(0x0 = 0)
  * const: symopt_debug - ast.Type(0x0 = 0)
  * const: std_output_handle - ast.Type(0x1c = 28)
  * const: std_error_handle - ast.Type(0x1c = 28)
  * const: enable_processed_output - ast.Type(0x1c = 28)
  * const: enable_wrap_at_eol_output - ast.Type(0x1c = 28)
  * const: evable_virtual_terminal_processing - ast.Type(0x1c = 28)       
  * const: format_message_allocate_buffer - ast.Type(0x1c = 28)
  * const: format_message_argument_array - ast.Type(0x0 = 0)
  * const: format_message_from_hmodule - ast.Type(0x0 = 0)
  * const: format_message_from_string - ast.Type(0x0 = 0)
  * const: format_message_from_system - ast.Type(0x1c = 28)
  * const: format_message_ignore_inserts - ast.Type(0x1c = 28)
  * const: none__ - ast.Type(0x1e = 30)
  * const: digit_pairs - ast.Type(0x15 = 21)
  * const: min_i8 - ast.Type(0x5 = 5)
  * const: max_i8 - ast.Type(0x5 = 5)
  * const: min_i16 - ast.Type(0x6 = 6)
  * const: max_i16 - ast.Type(0x6 = 6)
  * const: min_i32 - ast.Type(0x7 = 7)
  * const: max_i32 - ast.Type(0x7 = 7)
  * const: min_i64 - ast.Type(0x9 = 9)
  * const: max_i64 - ast.Type(0x9 = 9)
  * const: min_int - ast.Type(0x8 = 8)
  * const: max_int - ast.Type(0x8 = 8)
  * const: min_u8 - ast.Type(0x0 = 0)
  * const: max_u8 - ast.Type(0xb = 11)
  * const: min_u16 - ast.Type(0x0 = 0)
  * const: max_u16 - ast.Type(0xc = 12)
  * const: min_u32 - ast.Type(0x0 = 0)
  * const: max_u32 - ast.Type(0xd = 13)
  * const: min_u64 - ast.Type(0x0 = 0)
  * const: max_u64 - ast.Type(0xe = 14)
  * const: hashbits - ast.Type(0x1c = 28)
  * const: max_cached_hashbits - ast.Type(0x1c = 28)
  * const: init_log_capicity - ast.Type(0x1c = 28)
  * const: init_capicity - ast.Type(0x1c = 28)
  * const: max_load_factor - ast.Type(0x1b = 27)
  * const: init_even_index - ast.Type(0x1c = 28)
  * const: extra_metas_inc - ast.Type(0x1c = 28)
  * const: hash_mask - ast.Type(0xd = 13)
  * const: probe_inc - ast.Type(0xd = 13)
  * const: rune_maps_columns_in_row - ast.Type(0x1c = 28)
  * const: rune_maps_ul - ast.Type(0x1c = 28)
  * const: rune_maps_utl - ast.Type(0x1c = 28)
  * const: rune_maps - ast.Type(0xc6 = 198)
  * const: degree - ast.Type(0x1c = 28)
  * const: mid_index - ast.Type(0x1c = 28)
  * const: max_len - ast.Type(0x1c = 28)
  * const: children_bytes - ast.Type(0xd = 13)
  * const: replace_stack_buffer_size - ast.Type(0x1c = 28)
  * const: kmp_stack_buffer_size - ast.Type(0x1c = 28)
  * const: si_s_code - ast.Type(0x15 = 21)
  * const: si_g32_code - ast.Type(0x15 = 21)
  * const: si_g64_code - ast.Type(0x15 = 21)
  * const: cp_acp - ast.Type(0x1c = 28)
  * const: cp_utf8 - ast.Type(0x1c = 28)
  * const: builtin.closure.assumed_page_size - ast.Type(0x8 = 8)
  * const: builtin.closure.closure_thunk - ast.Type(0xa7 = 167)
  * const: builtin.closure.closure_get_data_bytes - ast.Type(0xa8 = 168)  
  * const: builtin.closure.closure_size_1 - ast.Type(0xd = 13)
  * const: builtin.closure.closure_size - ast.Type(0x8 = 8)
  * const: strconv.single_plus_zero - ast.Type(0xd = 13)
  * const: strconv.single_minus_zero - ast.Type(0xd = 13)
  * const: strconv.single_plus_infinity - ast.Type(0xd = 13)
  * const: strconv.single_minus_infinity - ast.Type(0xd = 13)
  * const: strconv.digits - ast.Type(0x1c = 28)
  * const: strconv.double_plus_zero - ast.Type(0xe = 14)
  * const: strconv.double_minus_zero - ast.Type(0xe = 14)
  * const: strconv.double_plus_infinity - ast.Type(0xe = 14)
  * const: strconv.double_minus_infinity - ast.Type(0xe = 14)
  * const: strconv.c_dpoint - ast.Type(0x0 = 0)
  * const: strconv.c_plus - ast.Type(0x16 = 22)
  * const: strconv.c_minus - ast.Type(0x16 = 22)
  * const: strconv.c_zero - ast.Type(0x16 = 22)
  * const: strconv.c_nine - ast.Type(0x16 = 22)
  * const: strconv.c_ten - ast.Type(0xd = 13)
  * const: strconv.pos_exp - ast.Type(0xaa = 170)
  * const: strconv.neg_exp - ast.Type(0xab = 171)
  * const: strconv.int_size - ast.Type(0x1c = 28)
  * const: strconv.i64_min_int32 - ast.Type(0x9 = 9)
  * const: strconv.i64_max_int32 - ast.Type(0x9 = 9)
  * const: strconv.ten_pow_table_32 - ast.Type(0xac = 172)
  * const: strconv.mantbits32 - ast.Type(0xd = 13)
  * const: strconv.expbits32 - ast.Type(0xd = 13)
  * const: strconv.bias32 - ast.Type(0x1c = 28)
  * const: strconv.maxexp32 - ast.Type(0x1c = 28)
  * const: strconv.ten_pow_table_64 - ast.Type(0xad = 173)
  * const: strconv.mantbits64 - ast.Type(0xd = 13)
  * const: strconv.expbits64 - ast.Type(0xd = 13)
  * const: strconv.bias64 - ast.Type(0x1c = 28)
  * const: strconv.maxexp64 - ast.Type(0x1c = 28)
  * const: strconv.dec_round - ast.Type(0xb0 = 176)
  * const: strconv.max_size_f64_char - ast.Type(0x1c = 28)
  * const: strconv.digit_pairs - ast.Type(0x15 = 21)
  * const: strconv.base_digits - ast.Type(0x15 = 21)
  * const: strconv.pow5_num_bits_32 - ast.Type(0x1c = 28)
  * const: strconv.pow5_inv_num_bits_32 - ast.Type(0x1c = 28)
  * const: strconv.pow5_num_bits_64 - ast.Type(0x1c = 28)
  * const: strconv.pow5_inv_num_bits_64 - ast.Type(0x1c = 28)
  * const: strconv.powers_of_10 - ast.Type(0x0 = 0)
  * const: strconv.pow5_split_32 - ast.Type(0xb4 = 180)
  * const: strconv.pow5_inv_split_32 - ast.Type(0xb5 = 181)
  * const: strconv.pow5_split_64_x - ast.Type(0xaf = 175)
  * const: strconv.pow5_inv_split_64_x - ast.Type(0xae = 174)
  * const: math.bits.de_bruijn32 - ast.Type(0xd = 13)
  * const: math.bits.de_bruijn32tab - ast.Type(0xa2 = 162)
  * const: math.bits.de_bruijn64 - ast.Type(0xe = 14)
  * const: math.bits.de_bruijn64tab - ast.Type(0xa3 = 163)
  * const: math.bits.m0 - ast.Type(0xe = 14)
  * const: math.bits.m1 - ast.Type(0xe = 14)
  * const: math.bits.m2 - ast.Type(0xe = 14)
  * const: math.bits.m3 - ast.Type(0xe = 14)
  * const: math.bits.m4 - ast.Type(0xe = 14)
  * const: math.bits.n8 - ast.Type(0xb = 11)
  * const: math.bits.n16 - ast.Type(0xc = 12)
  * const: math.bits.n32 - ast.Type(0xd = 13)
  * const: math.bits.n64 - ast.Type(0xe = 14)
  * const: math.bits.two32 - ast.Type(0xe = 14)
  * const: math.bits.mask32 - ast.Type(0xe = 14)
  * const: math.bits.overflow_error - ast.Type(0x15 = 21)
  * const: math.bits.divide_error - ast.Type(0x0 = 0)
  * const: math.bits.ntz_8_tab - ast.Type(0xa9 = 169)
  * const: math.bits.pop_8_tab - ast.Type(0xa9 = 169)
  * const: math.bits.rev_8_tab - ast.Type(0xa9 = 169)
  * const: math.bits.len_8_tab - ast.Type(0xa9 = 169)

    is_test: false
    is_generated: false
    is_translated: false
    language: c
    idx: 0
    path: 'C:\dev\v\usingwindows\mymodule\mod.c.v'
    path_base: 'mod.c.v'
    scope: &# 0 - 40

    stmts: [module mymodule, [unhandled stmt str type: v.ast.TypeDecl ]]  
    imports: []
    auto_imports: []
    used_imports: []
    implied_imports: []
    embedded_files: []
    imported_symbols: {}
    imported_symbols_trie: KeywordsMatcherTrie{ /* nodes.len: 10 */ min_len: 999999, max_len: 0 }
    imported_symbols_used: {}        
    errors: []
    warnings: []
    notices: []
    generic_fns: []
    global_labels: []
    template_paths: []
    unique_prefix: '69696ced11bb3aae'
    is_parse_text: false
    is_template_text: false
}

A TypeDecl is correctly identified. When printing its properties, we get

ast.TypeDecl(ast.AliasTypeDecl{
    name: 'C.TEST'
    mod: 'mymodule'
    is_pub: true
    typ: ast.Type(0x9e = 158)
    pos: token.Pos{
        len: 10
        line_nr: 2
        pos: 19
        col: 0
        file_idx: 63
        last_line: 2
    }
    type_pos: token.Pos{
        len: 3
        line_nr: 2
        pos: 37
        col: 18
        file_idx: 63
        last_line: 2
    }
    comments: []
    attrs: []
    parent_type: ast.Type(0x8 = 8)
    is_markused: false
})

And now let's zoom in on println(C.TEST(0)).

println(C.TEST(0)) is an ast.ExprStmt

ast.ExprStmt{
    pos: token.Pos{
        len: 18
        line_nr: 4
        pos: 50
        col: 4
        file_idx: 39
        last_line: 4
    }
    comments: []
    expr: println(C.TEST(0))
    is_expr: false
    typ: ast.Type(0x0 = 0)
}

The .expr holds a ast.CallExpr, since println() is a function call

ast.CallExpr{
    or_block: ast.OrExpr{
        kind: absent
        pos: token.Pos{
            len: 1
            line_nr: 5
            pos: 69
            col: 0
            file_idx: 39
            last_line: 5
        }
        scope: &# 0 - 0

        err_used: false
        stmts: []
    }
    expected_arg_types: []
    concrete_types: []
    comments: []
    raw_concrete_types: []
    from_embed_types: []
    args: [C.TEST(0)]
    name: 'println'
    left: ast.NodeError
    mod: 'main'
    const_name: ''
    scope: &# 37 - 69

    name_pos: token.Pos{
        len: 7
        line_nr: 4
        pos: 50
        col: 4
        file_idx: 39
        last_line: 4
    }
    pos: token.Pos{
        len: 18
        line_nr: 4
        pos: 50
        col: 4
        file_idx: 39
        last_line: 4
    }
    concrete_list_pos: token.Pos{
        len: 1
        line_nr: 4
        pos: 57
        col: 11
        file_idx: 39
        last_line: 4
    }
    fn_var_type: ast.Type(0x0 = 0)
    nr_ret_values: -1
    return_type_generic: ast.Type(0x0 = 0)
    return_type: ast.Type(0x0 = 0)
    receiver_concrete_type: ast.Type(0x0 = 0)
    receiver_type: ast.Type(0x0 = 0)
    left_type: ast.Type(0x0 = 0)
    kind: println
    language: v
    is_file_translated: false
    comptime_ret_val: false
    is_static_method: false
    is_variadic: false
    is_c_variadic: false
    is_noreturn: false
    should_be_skipped: false
    is_keep_alive: false
    is_fn_a_const: false
    is_fn_var: false
    free_receiver: false
    is_field: false
    is_method: false
    is_ctor_new: false
    is_return_used: false
    is_expand_simple_interpolation: false
    is_unwrapped_fn_selector: false
}

.args[0] is an ast.CallArg that holds yet another ast.CallExpr

ast.CallExpr{
    or_block: ast.OrExpr{
        kind: absent
        pos: token.Pos{
            len: 1
            line_nr: 4
            pos: 67
            col: 21
            file_idx: 39
            last_line: 4
        }
        scope: &# 0 - 0

        err_used: false
        stmts: []
    }
    expected_arg_types: []
    concrete_types: []
    comments: []
    raw_concrete_types: []
    from_embed_types: []
    args: [0]
    name: 'C.TEST'
    left: ast.NodeError
    mod: 'main'
    const_name: ''
    scope: &# 37 - 69

    name_pos: token.Pos{
        len: 4
        line_nr: 4
        pos: 60
        col: 14
        file_idx: 39
        last_line: 4
    }
    pos: token.Pos{
        len: 7
        line_nr: 4
        pos: 60
        col: 14
        file_idx: 39
        last_line: 4
    }
    concrete_list_pos: token.Pos{
        len: 1
        line_nr: 4
        pos: 64
        col: 18
        file_idx: 39
        last_line: 4
    }
    fn_var_type: ast.Type(0x0 = 0)
    nr_ret_values: -1
    return_type_generic: ast.Type(0x0 = 0)
    return_type: ast.Type(0x0 = 0)
    receiver_concrete_type: ast.Type(0x0 = 0)
    receiver_type: ast.Type(0x0 = 0)
    left_type: ast.Type(0x0 = 0)
    kind: unknown
    language: c
    is_file_translated: false
    comptime_ret_val: false
    is_static_method: false
    is_variadic: false
    is_c_variadic: false
    is_noreturn: false
    should_be_skipped: false
    is_keep_alive: false
    is_fn_a_const: false
    is_fn_var: false
    free_receiver: false
    is_field: false
    is_method: false
    is_ctor_new: false
    is_return_used: true
    is_expand_simple_interpolation: false
    is_unwrapped_fn_selector: false
}

With the ast laid out, let's see how this ast is used. The check() function loops over all ast_file.stmts

v/vlib/v/checker/checker.v

Lines 274 to 283 in 2e983cf

	c.stmt_level = 0
	for mut stmt in ast_file.stmts {
	if stmt in [ast.ConstDecl, ast.ExprStmt] {
	c.expr_level = 0
	c.stmt(mut stmt)
	}
	if c.should_abort {
	return
	}
	}

println(C.TEST(0)) is handled as an ast.ExprStmt, and then further as a ast.CallExpr

v/vlib/v/checker/checker.v

Lines 2481 to 2489 in 2e983cf

	fn (mut c Checker) stmt(mut node ast.Stmt) {
	$if trace_checker ? {
	ntype := typeof(*node).replace('v.ast.', '')
	eprintln('checking: ${c.file.path:-30} | pos: ${node.pos.line_str():-39} | node: ${ntype} | ${node}')
	}
	c.expected_type = ast.void_type
	match mut node {
	ast.ExprStmt {
	node.typ = c.expr(mut node.expr)

v/vlib/v/checker/checker.v

Lines 3305 to 3326 in 2e983cf

	ast.CallExpr {
	mut ret_type := c.call_expr(mut node)
	if ret_type != 0 && c.table.sym(ret_type).kind == .alias {
	unaliased_type := c.table.unaliased_type(ret_type)
	if unaliased_type.has_option_or_result() {
	ret_type = unaliased_type
	}
	}
	if !ret_type.has_option_or_result() {
	c.expr_or_block_err(node.or_block.kind, node.name, node.or_block.pos,
	false)
	}
	if node.or_block.kind != .absent {
	if ret_type.has_flag(.option) {
	ret_type = ret_type.clear_flag(.option)
	}
	if ret_type.has_flag(.result) {
	ret_type = ret_type.clear_flag(.result)
	}
	}
	return ret_type
	}

The call_expr() function then calls fn_call (method_call is reserved for functions with a receiver)

v/vlib/v/checker/fn.v

Lines 779 to 800 in 8d1b900

	fn (mut c Checker) call_expr(mut node ast.CallExpr) ast.Type {
	// Check whether the inner function definition is before the call
	if var := node.scope.find_var(node.name) {
	if var.expr is ast.AnonFn && var.pos.pos > node.pos.pos {
	c.error('unknown function: ${node.name}', node.pos)
	}
	}
	// If the left expr has an or_block, it needs to be checked for legal or_block statement.
	left_type := c.expr(mut node.left)
	c.check_expr_option_or_result_call(node.left, left_type)
	// TODO: merge logic from method_call and fn_call
	// First check everything that applies to both fns and methods
	old_inside_fn_arg := c.inside_fn_arg
	c.inside_fn_arg = true
	mut continue_check := true
	node.left_type = left_type
	// Now call `method_call` or `fn_call` for specific checks.
	typ := if node.is_method {
	c.method_call(mut node, mut continue_check)
	} else {
	c.fn_call(mut node, mut continue_check)
	}

Inside fn_call, eventually the C.TEST symbol is attempted to be found in the table. However, it's not in there for some reason.

v/vlib/v/checker/fn.v

Lines 1179 to 1185 in 8d1b900

	if !found {
	if f := c.table.find_fn(fn_name) {
	found = true
	func = f
	unsafe { c.table.fns[fn_name].usages++ }
	}
	}

The next step is therefore to figure out why C.TEST is not being added to the table, or perhaps why other C.xxx symbols are present, for example C.MultiByteToWideChar.

I just realized that C.TEST is not being found by fn_call because C.TEST is of course not a function. In the correct case where the type alias is in the same file as the cast, C.TEST(0) is correctly identified as an ast.CastExpr. So the real task is to find why the parser outputs C.TEST(0) as ast.CallExpr instead of ast.CastExpr.

The parser has a table of all the types collected. Since the parser only works on a single file, it makes sense that when type C.TEST = int is defined in the same file, ast.CastExpr is properly output because it can find the c type alias in the table. is_c_type_cast is true when defined in the same file, false when not

I've added the following code to the ast.CallExpr case in the expr function in the checker

		ast.CallExpr {
+			// Casting a value to a C type alias is parsed as CallExpr
+			// instead of CastExpr if the type alias is defined in another file
+			if node.name.starts_with("C.") && node.name in c.table.type_idxs {
+				// println(node)
+				mut cast_expr_node := ast.CastExpr{
+					typ: 135
+					expr: ast.IntegerLiteral{
+						val: "0"
+						pos: node.concrete_list_pos
+					}
+					typname: node.name
+					expr_type: 8
+					pos: node.pos
+				}
+
+				return c.cast_expr(mut cast_expr_node)
+			}
			mut ret_type := c.call_expr(mut node)
			if ret_type != 0 && c.table.sym(ret_type).kind == .alias {
				unaliased_type := c.table.unaliased_type(ret_type)
				if unaliased_type.has_option_or_result() {
					ret_type = unaliased_type
				}
			}
			if !ret_type.has_option_or_result() {
				c.expr_or_block_err(node.or_block.kind, node.name, node.or_block.pos,
					false)
			}
			if node.or_block.kind != .absent {
				if ret_type.has_flag(.option) {
					ret_type = ret_type.clear_flag(.option)
				}
				if ret_type.has_flag(.result) {
					ret_type = ret_type.clear_flag(.result)
				}
			}
			return ret_type
		}

Today I added the same clause to cgen

ast.CallExpr {
+	if node.name.starts_with("C.") && node.name in g.table.type_idxs {
+		cast_expr_node := ast.CastExpr{
+			typ: 135
+			expr: ast.IntegerLiteral{
+				val: "0"
+				pos: node.concrete_list_pos
+			}
+			typname: node.name
+			expr_type: 8
+			pos: node.pos
+		}
+		g.cast_expr(cast_expr_node)
+		return
+	}
	ret_type := if node.or_block.kind == .absent {
		node.return_type
	} else {
		node.return_type.clear_option_and_result()
	}

And now it failed at gen/c/str.v:124 because println() has C.TEST(0) as its argument, and it is of type ast.CallExpr. At this point I was reluctant of trying to patch all the places with special handling of C type aliases, because there will for sure be a lot more places to fix it. Instead, the AST needs to be modified right after parsing, before the checker and cgen.

I'm approaching the end. parser.v's parse_files() function creates each ast.File. After all ast.File objects are created, the table has been populated with all the types. Only after all types have been added can we start replacing ast.CallExpr with ast.CastExpr, since we can't know in advance whether C.TEST(0) is a function or a type.

pub fn parse_files(paths []string, mut table ast.Table, pref_ &pref.Preferences) []&ast.File {
	mut timers := util.new_timers(should_print: false, label: 'parse_files: ${paths}')
	$if time_parsing ? {
		timers.should_print = true
	}
	unsafe {
		mut files := []&ast.File{cap: paths.len}
		for path in paths {
			timers.start('parse_file ${path}')
			files << parse_file(path, mut table, .skip_comments, pref_)
			timers.show('parse_file ${path}')
		}
+		replace_call_with_cast(mut files[40].stmts, mut table)
		handle_codegen_for_multiple_files(mut files)
		return files
	}
}

+fn replace_call_with_cast(mut stmts []ast.Stmt, mut table ast.Table) {
+	for mut stmt in stmts {
+		mut as_node := ast.Node(stmt)
+		replace_call_with_cast_recursive(mut as_node, mut table)
+	}
+}
+
+fn replace_call_with_cast_recursive(mut node ast.Node, mut table ast.Table) {
+	mut children := node.children()
+	if children.len == 0 {
+		return
+	}
+
+	for mut child in children {
+		replace_call_with_cast_recursive(mut child, mut table)+
+
+		if mut child is ast.Expr {
+			as_expr := child as ast.Expr
+			match as_expr {
+				ast.CallExpr {
+					if as_expr.name.startsWith('C.') && as_expr.name in table.type_idxs {
+						child = ast.Node(ast.CastExpr{
+							typ: 230
+							expr: ast.IntegerLiteral{
+								val: "0"
+								pos: node.concrete_list_pos
+							}
+							typname: node.name
+							expr_type: 8
+							pos: node.pos
+						})
+					}
+				}
+				else {}
+			}
+		}
+	}
+}