cgen: fix codegen to make mutable sumtype working (fix #23982, part 1, needed for bootstrapping) (#23988)

felipensp · web-flow · commit 3920bc155fdd · 2025-03-22T17:40:59.000+02:00
diff --git a/vlib/v/gen/c/assign.v b/vlib/v/gen/c/assign.v
@@ -127,8 +127,8 @@ fn (mut g Gen) expr_opt_with_cast(expr ast.Expr, expr_typ ast.Type, ret_typ ast.
 				if ret_sym.kind == .sum_type {
 					exp_sym := g.table.sym(expr_typ)
 					fname := g.get_sumtype_casting_fn(expr_typ, ret_typ)
-					g.call_cfn_for_casting_expr(fname, expr, ret_typ, ret_sym.cname, expr_typ.is_ptr(),
-						exp_sym.kind == .function, g.styp(expr_typ))
+					g.call_cfn_for_casting_expr(fname, expr, ret_typ, expr_typ, ret_sym.cname,
+						expr_typ.is_ptr(), exp_sym.kind == .function, g.styp(expr_typ))
 				} else {
 					g.write('*((${g.base_type(expr_typ)}*)')
 					g.expr(expr)
diff --git a/vlib/v/gen/c/cgen.v b/vlib/v/gen/c/cgen.v
@@ -240,6 +240,7 @@ mut:
 	referenced_fns      shared map[string]bool // functions that have been referenced
 	nr_closures         int
 	expected_cast_type  ast.Type // for match expr of sumtypes
+	expected_arg_mut    bool     // generating a mutable fn parameter
 	or_expr_return_type ast.Type // or { 0, 1 } return type
 	anon_fn             bool
 	tests_inited        bool
@@ -2750,18 +2751,33 @@ fn (mut g Gen) write_sumtype_casting_fn(fun SumtypeCastingFn) {
 	g.auto_fn_definitions << sb.str()
 }
 
-fn (mut g Gen) call_cfn_for_casting_expr(fname string, expr ast.Expr, exp ast.Type, exp_styp string,
+fn (mut g Gen) call_cfn_for_casting_expr(fname string, expr ast.Expr, exp ast.Type, got ast.Type, exp_styp string,
 	got_is_ptr bool, got_is_fn bool, got_styp string) {
 	mut rparen_n := 1
-	is_comptime_variant := expr is ast.Ident && g.comptime.is_comptime_variant_var(expr)
+	mut mutable_idx := 0
+
+	is_not_ptr_and_fn := !got_is_ptr && !got_is_fn
+	is_sumtype_cast := is_not_ptr_and_fn && fname.contains('_to_sumtype_')
+	is_comptime_variant := is_not_ptr_and_fn && expr is ast.Ident
+		&& g.comptime.is_comptime_variant_var(expr)
+
 	if exp.is_ptr() {
-		g.write('HEAP(${exp_styp}, ')
-		rparen_n++
+		if $d('mutable_sumtype', false) && is_sumtype_cast && g.expected_arg_mut
+			&& expr is ast.Ident {
+			g.write('&(${exp_styp.trim_right('*')}){._${got_styp.trim_right('*')}=')
+			rparen_n = 0
+			mutable_idx = got.idx()
+		} else {
+			g.write('HEAP(${exp_styp}, ${fname}(')
+			rparen_n++
+		}
+	} else {
+		g.write('${fname}(')
 	}
-	g.write('${fname}(')
-	if !got_is_ptr && !got_is_fn {
+	if is_not_ptr_and_fn {
 		is_cast_fixed_array_init := expr is ast.CastExpr
 			&& (expr.expr is ast.ArrayInit && expr.expr.is_fixed)
+
 		if !is_cast_fixed_array_init && (is_comptime_variant || !expr.is_lvalue()
 			|| (expr is ast.Ident && expr.obj.is_simple_define_const())) {
 			// Note: the `_to_sumtype_` family of functions do call memdup internally, making
@@ -2777,7 +2793,7 @@ fn (mut g Gen) call_cfn_for_casting_expr(fname string, expr ast.Expr, exp ast.Ty
 					g.inside_smartcast = old_inside_smartcast
 				}
 			} else {
-				promotion_macro_name := if fname.contains('_to_sumtype_') { 'ADDR' } else { 'HEAP' }
+				promotion_macro_name := if is_sumtype_cast { 'ADDR' } else { 'HEAP' }
 				g.write('${promotion_macro_name}(${got_styp}, (')
 				rparen_n += 2
 			}
@@ -2797,6 +2813,9 @@ fn (mut g Gen) call_cfn_for_casting_expr(fname string, expr ast.Expr, exp ast.Ty
 		g.expr(expr)
 		g.left_is_opt = old_left_is_opt
 	}
+	if mutable_idx != 0 {
+		g.write(', ._typ=${mutable_idx}}')
+	}
 	g.write(')'.repeat(rparen_n))
 }
 
@@ -2889,8 +2908,8 @@ fn (mut g Gen) expr_with_cast(expr ast.Expr, got_type_raw ast.Type, expected_typ
 			if exp_sym.info.is_generic {
 				fname = g.generic_fn_name(exp_sym.info.concrete_types, fname)
 			}
-			g.call_cfn_for_casting_expr(fname, expr, expected_type, exp_styp, true, false,
-				got_styp)
+			g.call_cfn_for_casting_expr(fname, expr, expected_type, got_type, exp_styp,
+				true, false, got_styp)
 			g.inside_cast_in_heap--
 		} else {
 			got_styp := g.cc_type(got_type, true)
@@ -2916,8 +2935,8 @@ fn (mut g Gen) expr_with_cast(expr ast.Expr, got_type_raw ast.Type, expected_typ
 					return
 				}
 			}
-			g.call_cfn_for_casting_expr(fname, expr, expected_type, exp_styp, got_is_ptr,
-				false, got_styp)
+			g.call_cfn_for_casting_expr(fname, expr, expected_type, got_type, exp_styp,
+				got_is_ptr, false, got_styp)
 		}
 		return
 	}
@@ -2981,8 +3000,8 @@ fn (mut g Gen) expr_with_cast(expr ast.Expr, got_type_raw ast.Type, expected_typ
 					g.write('${fname}(&${tmp_var})')
 					return
 				} else {
-					g.call_cfn_for_casting_expr(fname, expr, expected_type, unwrapped_exp_sym.cname,
-						got_is_ptr, got_is_fn, got_styp)
+					g.call_cfn_for_casting_expr(fname, expr, expected_type, got_type,
+						unwrapped_exp_sym.cname, got_is_ptr, got_is_fn, got_styp)
 				}
 			}
 			return
diff --git a/vlib/v/gen/c/fn.v b/vlib/v/gen/c/fn.v
@@ -2615,6 +2615,11 @@ fn (mut g Gen) ref_or_deref_arg(arg ast.CallArg, expected_type ast.Type, lang as
 	if expected_type == 0 {
 		g.checker_bug('ref_or_deref_arg expected_type is 0', arg.pos)
 	}
+	old_expected_arg_mut := g.expected_arg_mut
+	g.expected_arg_mut = arg.is_mut
+	defer {
+		g.expected_arg_mut = old_expected_arg_mut
+	}
 	exp_sym := g.table.sym(expected_type)
 	mut needs_closing := false
 	old_inside_smartcast := g.inside_smartcast
diff --git a/vlib/v/tests/sumtypes/sumtype_arg_mutable_test.v b/vlib/v/tests/sumtypes/sumtype_arg_mutable_test.v
@@ -0,0 +1,41 @@
+struct Int {
+mut:
+	i int
+}
+
+struct String {
+mut:
+	s string
+}
+
+type Sum = Int | String
+
+fn init(mut s Sum) {
+	match mut s {
+		Int { s.i = 0 }
+		String { s.s = '' }
+	}
+}
+
+fn init_int(mut i Int) {
+	i.i = 0
+}
+
+fn test_main() {
+	mut i := Int{
+		i: 333
+	}
+	mut s := String{
+		s: 'string'
+	}
+	if $d('mutable_sumtype', false) {
+		assert i.i == 333
+		assert s.s == 'string'
+		init(mut i)
+		init(mut s)
+		assert i.i == 0
+		assert s.s == ''
+		init_int(mut i)
+		assert i.i == 0
+	}
+}
