pref: fix cross compiling to windows

Author: medvednikov

vlib/v/pref/default.v

@@ -242,9 +242,9 @@ fn (mut p Preferences) find_cc_if_cross_compiling() {
 		return
 	}
 	if p.ccompiler_set_by_flag {
-		// tcc cannot cross-compile for Windows (no Windows headers),
-		// so override it with the proper cross-compiler.
-		if p.os == .windows && p.ccompiler.contains('tcc') {
+		// Only mingw compilers can cross-compile for Windows (others lack Windows headers),
+		// so override any non-mingw compiler with the proper cross-compiler.
+		if p.os == .windows && !p.ccompiler.contains('mingw') {
 			p.ccompiler = p.vcross_compiler_name()
 			return
 		}

vlib/v2/gen/cleanc/expr.v

@@ -1492,6 +1492,11 @@ fn (mut g Gen) expr(node ast.Expr) {
 			lhs_expr := sel.lhs
 			rhs_name := sel.rhs.name
 			lhs_name := if lhs_expr is ast.Ident { sel.lhs.name() } else { '' }
+			if lhs_name == 'c' && rhs_name in ['a', 'r', 'g', 'b'] && g.cur_module == 'gg' {
+				eprintln('[debug-sel] c.${rhs_name} in ${g.cur_module}::${g.cur_fn_name}, is_known_var=${g.local_var_c_type_for_expr(lhs_expr) != none}, local_type=${g.get_local_var_c_type('c') or {
+					'NONE'
+				}}')
+			}
 			// C.<ident> references C macros/constants directly (e.g. C.EOF -> EOF).
 			if lhs_expr is ast.Ident {
 				if lhs_name == 'C' {

vlib/v2/gen/cleanc/fn.v

@@ -1171,11 +1171,19 @@ fn (mut g Gen) gen_call_arg(fn_name string, idx int, arg ast.Expr) {
 				// Selector/index expressions can be smartcast-narrowed in the checker env,
 				// while still evaluating to the original sum value representation.
 				// If the raw (declared) type already matches the sum param type, pass it through.
+				// But verify with get_expr_type: if it returns a known variant, the raw type
+				// lookup hit the wrong scope entry (e.g. struct field vs. local variable).
 				if raw := g.get_raw_type(base_arg) {
 					raw_c := g.types_type_to_c(raw)
 					if raw_c == param_type {
-						g.expr(base_arg)
-						return
+						expr_type := g.get_expr_type(base_arg)
+						if expr_type == param_type || expr_type == '' || expr_type == 'int'
+							|| expr_type !in variants {
+							g.expr(base_arg)
+							return
+						}
+						// expr_type is a known variant but raw_type says sum type:
+						// raw_type lookup was wrong, fall through to wrapping
 					}
 				}
 				mut arg_type := g.get_expr_type(base_arg)