autofree: fix support for match exprs with nested if exprs (#26599)

Author: esquerbatua

vlib/v/gen/c/cgen.v

@@ -164,6 +164,7 @@ mut:
 	inside_global_decl        bool
 	inside_interface_deref    bool
 	inside_assign_fn_var      bool
+	outer_tmp_var             string // tmp var from outer context (e.g. from stmts_with_tmp_var) to be used by nested if/match expressions
 	last_tmp_call_var         []string
 	last_if_option_type       ast.Type // stores the expected if type on nested if expr
 	loop_depth                int
@@ -2356,6 +2357,7 @@ fn (mut g Gen) stmts_with_tmp_var(stmts []ast.Stmt, tmp_var string) bool {
 				g.set_current_pos_as_last_stmt_pos()
 				g.skip_stmt_pos = true
 				mut is_noreturn := false
+				mut is_if_expr_with_tmp := false
 				if stmt in [ast.Return, ast.BranchStmt] {
 					is_noreturn = true
 				} else if stmt is ast.ExprStmt {
@@ -2364,15 +2366,24 @@ fn (mut g Gen) stmts_with_tmp_var(stmts []ast.Stmt, tmp_var string) bool {
 						is_array_fixed_init = true
 						ret_type = stmt.expr.typ
 					}
+					if stmt.expr is ast.IfExpr && g.is_autofree && !g.inside_if_option
+						&& !g.inside_if_result {
+						is_if_expr_with_tmp = true
+						g.outer_tmp_var = tmp_var
+					}
 				}
-				if !is_noreturn {
+				if !is_noreturn && !is_if_expr_with_tmp {
 					if is_array_fixed_init {
 						g.write('memcpy(${tmp_var}, (${g.styp(ret_type)})')
 					} else {
 						g.write('${tmp_var} = ')
 					}
 				}
 				g.stmt(stmt)
+				// Reset outer_tmp_var after processing
+				if is_if_expr_with_tmp {
+					g.outer_tmp_var = ''
+				}
 				if is_array_fixed_init {
 					lines := g.go_before_last_stmt().trim_right('; \n')
 					g.writeln('${lines}, sizeof(${tmp_var}));')

vlib/v/gen/c/if.v

@@ -181,15 +181,24 @@ fn (mut g Gen) needs_conds_order(node ast.IfExpr) bool {
 }
 
 fn (mut g Gen) if_expr(node ast.IfExpr) {
+	use_outer_tmp := g.outer_tmp_var != ''
+	saved_outer_tmp_var := g.outer_tmp_var
+	if use_outer_tmp {
+		g.outer_tmp_var = ''
+	}
+
 	// For simple if expressions we can use C's `?:`
 	// `if x > 0 { 1 } else { 2 }` => `(x > 0)? (1) : (2)`
 	// For if expressions with multiple statements or another if expression inside, it's much
 	// easier to use a temp var, than do C tricks with commas, introduce special vars etc
 	// (as it used to be done).
 	// Always use this in -autofree, since ?: can have tmp expressions that have to be freed.
-	needs_tmp_var := g.inside_if_option || g.need_tmp_var_in_if(node)
+	needs_tmp_var := g.inside_if_option || g.need_tmp_var_in_if(node) || use_outer_tmp
 	needs_conds_order := g.needs_conds_order(node)
-	tmp := if g.inside_if_option || (node.typ != ast.void_type && needs_tmp_var) {
+	tmp := if use_outer_tmp {
+		// Use the tmp var from outer context (e.g. from stmts_with_tmp_var)
+		saved_outer_tmp_var
+	} else if g.inside_if_option || (node.typ != ast.void_type && needs_tmp_var) {
 		g.new_tmp_var()
 	} else {
 		''
@@ -267,7 +276,8 @@ fn (mut g Gen) if_expr(node ast.IfExpr) {
 		}
 		cur_line = g.go_before_last_stmt()
 		g.empty_line = true
-		if tmp != '' {
+		if tmp != '' && !use_outer_tmp {
+			// Only declare the tmp var if it's not from outer context
 			if node.typ == ast.void_type && g.last_if_option_type != 0 {
 				// nested if on return stmt
 				g.write2(g.styp(g.unwrap_generic(g.last_if_option_type)), ' ')

vlib/v/slow_tests/valgrind/autofree_match_sumtype_test.v

@@ -0,0 +1,53 @@
+// vtest vflags: -autofree
+// vtest build: !sanitize-address-gcc && !sanitize-address-clang
+
+type Result = Success | Failure
+
+struct Success {
+	value int
+}
+
+struct Failure {
+	msg string
+}
+
+fn process(r Result) Result {
+	return match r {
+		Success {
+			if r.value > 10 {
+				Success{
+					value: r.value * 2
+				}
+			} else {
+				r
+			}
+		}
+		Failure {
+			r
+		}
+	}
+}
+
+fn test_autofree_match_with_nested_if() {
+	r := process(Success{
+		value: 15
+	})
+	assert r is Success
+	assert (r as Success).value == 30
+}
+
+fn test_autofree_match_with_nested_if_else() {
+	r := process(Success{
+		value: 5
+	})
+	assert r is Success
+	assert (r as Success).value == 5
+}
+
+fn test_autofree_match_error_branch() {
+	r := process(Failure{
+		msg: 'test error'
+	})
+	assert r is Failure
+	assert (r as Failure).msg == 'test error'
+}

vlib/v/slow_tests/valgrind/autofree_match_test.v

@@ -0,0 +1,40 @@
+// vtest vflags: -autofree
+// vtest build: !sanitize-address-gcc && !sanitize-address-clang
+
+type Tree[T] = Empty | Node[T]
+
+struct Empty {}
+
+struct Node[T] {
+	value T
+	left  Tree[T]
+	right Tree[T]
+}
+
+fn (tree Tree[T]) delete[T](x T) Tree[T] {
+	return match tree {
+		Empty {
+			tree
+		}
+		Node[T] {
+			if tree.left !is Empty && tree.right !is Empty {
+				if x < tree.value {
+					Node[T]{
+						...tree
+						left: tree.left.delete(x)
+					}
+				} else {
+					tree
+				}
+			} else {
+				tree
+			}
+		}
+	}
+}
+
+fn test_autofree_match() {
+	mut tree := Tree[int](Empty{})
+	tree = tree.delete(5)
+	assert tree is Empty
+}