cgen: cast member variables to correct types in comptime $for (fix #25771) (#25773)

Author: dy-tea

vlib/v/gen/c/cgen.v

@@ -5293,6 +5293,27 @@ fn (mut g Gen) select_expr(node ast.SelectExpr) {
 	}
 }
 
+fn (mut g Gen) is_comptime_for_var(node ast.Ident) bool {
+	if !g.comptime.inside_comptime_for || g.comptime.comptime_for_field_var == '' {
+		return false
+	}
+	if node.obj is ast.Var {
+		obj_typ := node.obj.typ
+		field_typ := g.comptime.comptime_for_field_type
+		return (obj_typ.has_flag(.option) && field_typ.has_flag(.option))
+			|| (obj_typ.clear_flag(.option).idx() == field_typ.clear_flag(.option).idx()
+			&& obj_typ.has_flag(.option))
+	}
+	return false
+}
+
+fn (mut g Gen) get_comptime_for_var_type(node ast.Ident, default_typ ast.Type) ast.Type {
+	if g.is_comptime_for_var(node) {
+		return g.comptime.comptime_for_field_type
+	}
+	return default_typ
+}
+
 fn (mut g Gen) ident(node ast.Ident) {
 	prevent_sum_type_unwrapping_once := g.prevent_sum_type_unwrapping_once
 	g.prevent_sum_type_unwrapping_once = false
@@ -5391,7 +5412,8 @@ fn (mut g Gen) ident(node ast.Ident) {
 					g.write(name)
 				}
 			} else {
-				g.unwrap_option_type(node.info.typ, name, is_auto_heap)
+				unwrap_typ := g.get_comptime_for_var_type(node, node.info.typ)
+				g.unwrap_option_type(unwrap_typ, name, is_auto_heap)
 			}
 			if node.or_expr.kind != .absent && !(g.inside_opt_or_res && g.inside_assign
 				&& !g.is_assign_lhs) {
@@ -5439,7 +5461,9 @@ fn (mut g Gen) ident(node ast.Ident) {
 				g.write('(*(')
 			}
 			is_option = is_option || node.obj.orig_type.has_flag(.option)
-			if node.obj.smartcasts.len > 0 {
+			// Skip smartcasts for comptime_for variables to avoid using stale types
+			skip_smartcasts := g.is_comptime_for_var(node)
+			if node.obj.smartcasts.len > 0 && !skip_smartcasts {
 				obj_sym := g.table.final_sym(g.unwrap_generic(node.obj.typ))
 				if !prevent_sum_type_unwrapping_once {
 					nested_unwrap := node.obj.smartcasts.len > 1
@@ -5473,7 +5497,8 @@ fn (mut g Gen) ident(node ast.Ident) {
 							&& g.table.type_kind(node.obj.typ) == .any) {
 							g.write('*')
 						} else if is_option {
-							g.write('*(${g.base_type(node.obj.typ)}*)')
+							unwrap_typ := g.get_comptime_for_var_type(node, node.obj.typ)
+							g.write('*(${g.base_type(unwrap_typ)}*)')
 						}
 					}
 					for i, typ in node.obj.smartcasts {

vlib/v/gen/c/str_intp.v

@@ -220,7 +220,8 @@ fn (mut g Gen) str_val(node ast.StringInterLiteral, i int, fmts []u8) {
 		g.write2('${dot}_object', ')')
 	} else if fmt == `s` || typ.has_flag(.variadic) {
 		mut exp_typ := typ
-		if expr is ast.Ident {
+		is_comptime_for_var := expr is ast.Ident && g.is_comptime_for_var(expr)
+		if !is_comptime_for_var && expr is ast.Ident {
 			if g.comptime.get_ct_type_var(expr) == .smartcast {
 				exp_typ = g.type_resolver.get_type(expr)
 			} else if expr.obj is ast.Var {
@@ -236,7 +237,17 @@ fn (mut g Gen) str_val(node ast.StringInterLiteral, i int, fmts []u8) {
 				}
 			}
 		}
-		g.gen_expr_to_string(expr, exp_typ)
+		if exp_typ.has_flag(.option) && expr is ast.Ident && g.is_comptime_for_var(expr) {
+			str_fn_name := g.get_str_fn(exp_typ.clear_flag(.option))
+			g.write('${str_fn_name}(*(${g.base_type(exp_typ)}*)(')
+			old_inside_opt_or_res := g.inside_opt_or_res
+			g.inside_opt_or_res = true
+			g.expr(expr)
+			g.inside_opt_or_res = old_inside_opt_or_res
+			g.write('.data))')
+		} else {
+			g.gen_expr_to_string(expr, exp_typ)
+		}
 	} else if typ.is_number() || typ.is_pointer() || fmt == `d` {
 		if typ.is_signed() && fmt in [`x`, `X`, `o`] {
 			// convert to unsigned first befors C's integer propagation strikes
@@ -283,26 +294,26 @@ fn (mut g Gen) string_inter_literal(node ast.StringInterLiteral) {
 	mut node_ := unsafe { node }
 	mut fmts := node_.fmts.clone()
 	for i, mut expr in node_.exprs {
-		mut type_to_use := node_.expr_types[i]
+		mut field_typ := if mut expr is ast.Ident && g.is_comptime_for_var(expr) {
+			g.comptime.comptime_for_field_type
+		} else {
+			node_.expr_types[i]
+		}
 		if g.comptime.inside_comptime_for && mut expr is ast.SelectorExpr {
 			if expr.expr is ast.TypeOf && expr.field_name == 'name' {
-				// This is typeof(var).name
 				typeof_expr := expr.expr as ast.TypeOf
 				if typeof_expr.expr is ast.Ident {
 					ident_name := (typeof_expr.expr as ast.Ident).name
-					// Check if this ident might be from a multi-return in the current scope
-					// For now, force re-evaluation by looking it up in the comptime context
 					if obj := typeof_expr.expr.scope.find(ident_name) {
 						if obj is ast.Var {
-							// Use the var's actual type, which might be correct in codegen context
-							type_to_use = obj.typ
+							field_typ = obj.typ
 						}
 					}
 				}
 			}
 		}
-		if g.comptime.is_comptime(expr) {
-			ctyp := g.type_resolver.get_type_or_default(expr, node_.expr_types[i])
+		if g.comptime.is_comptime(expr) || (g.comptime.inside_comptime_for && expr is ast.Ident) {
+			ctyp := g.type_resolver.get_type_or_default(expr, field_typ)
 			if ctyp != ast.void_type {
 				node_.expr_types[i] = ctyp
 				if node_.fmts[i] == `_` {
@@ -316,7 +327,7 @@ fn (mut g Gen) string_inter_literal(node ast.StringInterLiteral) {
 				}
 			}
 		} else {
-			node_.expr_types[i] = type_to_use
+			node_.expr_types[i] = field_typ
 		}
 	}
 	g.write2('builtin__str_intp(', node.vals.len.str())

vlib/v/tests/comptime/comptime_for_in_options_struct_test.v

@@ -10,7 +10,7 @@ fn unwrap_not_none_field_types[T](t T) []string {
 		v := t.$(f.name)
 		$if f is $option {
 			if v != none {
-				arr << typeof(v).name
+				arr << '${typeof(v).name}:${f.name}=`${v}`'
 			}
 		}
 	}
@@ -23,5 +23,5 @@ fn test_main() {
 		b: 1
 		c: 2.3
 	})
-	assert arr.join(' ') == 'string int f64'
+	assert arr.join(' ') == 'string:a=`x` int:b=`1` f64:c=`2.3`'
 }

vlib/v/tests/comptime/comptime_var_assignment_test.v

@@ -26,6 +26,6 @@ fn test_main() {
 	out := encode_struct(FixedStruct1{1, 'foo', 4, 'bar'})
 	assert out[0] == '1'
 	assert out[1] == 'foo'
-	assert out[2] == 'Option(4)'
-	assert out[3] == "Option('bar')"
+	assert out[2] == '4'
+	assert out[3] == 'bar'
 }