cgen: cast fix

Author: medvednikov

vlib/v/gen/c/fn.v

@@ -5682,6 +5682,20 @@ fn (mut g Gen) ref_or_deref_arg(arg ast.CallArg, expected_type_ ast.Type, lang a
 		g.expected_arg_mut = old_expected_arg_mut
 	}
 	exp_sym := g.table.sym(expected_type)
+	// Cast function pointer arguments when the expected and actual types differ.
+	// V's checker allows coercing function types (e.g. Renderer* → voidptr in callbacks),
+	// but C compilers with -Werror=incompatible-pointer-types reject the mismatch.
+	// Only cast for V language calls with named function type aliases (not anonymous fn types).
+	if exp_sym.kind == .function && arg_sym.kind == .function && !arg.is_mut && lang == .v
+		&& !exp_sym.name.starts_with('fn ') {
+		exp_styp := g.styp(expected_type)
+		arg_styp := g.styp(arg_typ)
+		if exp_styp != arg_styp {
+			g.write('(${exp_styp})')
+			g.expr(arg.expr)
+			return
+		}
+	}
 	if arg.is_mut && exp_sym.kind in [.interface, .sum_type] {
 		expected_wrap_type := if expected_type.is_ptr() {
 			expected_type.deref()

vlib/v/gen/c/struct.v

@@ -897,20 +897,32 @@ fn (mut g Gen) struct_init_field(sfield ast.StructInitField, language ast.Langua
 		&& g.cur_struct_init_typ != 0 {
 		struct_sym := g.table.sym(g.cur_struct_init_typ)
 		if struct_sym.info is ast.Struct {
-			for f in struct_sym.info.fields {
-				if f.name == sfield.name {
-					// Only cast named function type aliases (e.g. ThreadCB),
-					// not anonymous function types from generic structs which
-					// may generate non-existent type names.
-					fsym := g.table.sym(f.typ)
-					if !fsym.name.starts_with('fn ') {
-						field_styp := g.styp(f.typ)
-						expr_styp := g.styp(sfield.typ)
-						if field_styp != expr_styp {
-							g.write('(${field_styp})')
+			if struct_sym.info.is_typedef {
+				// For @[typedef] C structs, the actual C field types may differ
+				// from V's declarations (e.g. C has `const char*` but V uses `char*`).
+				// Use __typeof__ to cast to the actual C struct field type.
+				c_struct_name := if struct_sym.cname.starts_with('C__') {
+					struct_sym.cname[3..]
+				} else {
+					struct_sym.cname
+				}
+				g.write('(__typeof__(((${c_struct_name}){}).${sfield.name}))')
+			} else {
+				for f in struct_sym.info.fields {
+					if f.name == sfield.name {
+						// Only cast named function type aliases (e.g. ThreadCB),
+						// not anonymous function types from generic structs which
+						// may generate non-existent type names.
+						fsym := g.table.sym(f.typ)
+						if !fsym.name.starts_with('fn ') {
+							field_styp := g.styp(f.typ)
+							expr_styp := g.styp(sfield.typ)
+							if field_styp != expr_styp {
+								g.write('(${field_styp})')
+							}
 						}
+						break
 					}
-					break
 				}
 			}
 		}