parser: fix match-arm !/? propagation when a match is used as a block value (fix #28000)

vlib/v/checker/checker.v

@@ -4867,7 +4867,18 @@ pub fn (mut c Checker) expr(mut node ast.Expr) ast.Type {
 			return c.array_init(mut node)
 		}
 		ast.AsCast {
-			node.expr_type = c.expr(mut node.expr)
+			if c.expected_type == ast.void_type && operand_is_value_match_or_if(node.expr) {
+				// A `match`/`if` operand of an `as` cast is a value expression, e.g.
+				// `(match x { ... }) as Variant`. Give it a non-void expected type so
+				// it is checked as an expression (`is_expr`) even when nested in a
+				// void context (e.g. an if-branch), instead of being typed as `void`.
+				old_expected_type := c.expected_type
+				c.expected_type = node.typ
+				node.expr_type = c.expr(mut node.expr)
+				c.expected_type = old_expected_type
+			} else {
+				node.expr_type = c.expr(mut node.expr)
+			}
 			expr_type_sym := c.table.sym(node.expr_type)
 			type_sym := c.table.sym(c.unwrap_generic(node.typ))
 			if mut node.expr is ast.Ident {
@@ -5414,6 +5425,23 @@ fn integer_literal_from_pointer_cast_expr(expr ast.Expr) ?ast.IntegerLiteral {
 	}
 }
 
+// operand_is_value_match_or_if reports whether an expression is a `match`/`if`
+// expression used as a value, looking through transparent `(...)` and
+// `unsafe { }` wrappers (including compositions like `unsafe { match ... }`).
+// Such an operand of a cast or infix expression must be checked with a non-void
+// expected type so it is treated as `is_expr`, even when the surrounding expected
+// type is void (e.g. nested inside an if-branch) — otherwise it is mistyped as
+// `void`.
+fn operand_is_value_match_or_if(expr ast.Expr) bool {
+	if expr is ast.ParExpr {
+		return operand_is_value_match_or_if(expr.expr)
+	}
+	if expr is ast.UnsafeExpr {
+		return operand_is_value_match_or_if(expr.expr)
+	}
+	return expr is ast.MatchExpr || expr is ast.IfExpr
+}
+
 fn (mut c Checker) cast_expr(mut node ast.CastExpr) ast.Type {
 	// Given: `Outside( Inside(xyz) )`,
 	//        node.expr_type: `Inside`
@@ -5454,6 +5482,13 @@ fn (mut c Checker) cast_expr(mut node ast.CastExpr) ast.Type {
 		c.expected_type = base_to_type
 	} else if node.expr is ast.IndexExpr && to_type.has_flag(.option) {
 		c.expected_type = to_type
+	} else if c.expected_type == ast.void_type && operand_is_value_match_or_if(node.expr) {
+		// A `match`/`if` operand of a cast is a value expression, e.g.
+		// `i64(match x { ... })`. Propagate the cast target as its expected type
+		// so it is checked as an expression (`is_expr`) even in contexts where
+		// the surrounding expected type is void (e.g. nested inside an if-branch),
+		// instead of being mistyped as `void` ("does not return a value").
+		c.expected_type = base_to_type
 	}
 	expr_is_ident_or_cast := node.expr is ast.Ident || node.expr is ast.CastExpr
 	node.expr_type = c.expr(mut node.expr) // type to be casted

vlib/v/checker/infix.v

@@ -113,20 +113,29 @@ fn (mut c Checker) infix_expr(mut node ast.InfixExpr) ast.Type {
 	}
 	// In bool contexts like `assert` and `return`, short enum literals on the left
 	// need the right operand type first, so `.a == x` resolves `.a` correctly.
-	mut check_right_type_first_for_left_short_enum := false
+	mut check_right_type_first := false
 	if node.op in [.eq, .ne] && node.left is ast.EnumVal {
 		left_enum := node.left as ast.EnumVal
 		if left_enum.enum_name.len == 0 {
 			if node.right is ast.EnumVal {
 				right_enum := node.right as ast.EnumVal
-				check_right_type_first_for_left_short_enum = right_enum.enum_name.len > 0
+				check_right_type_first = right_enum.enum_name.len > 0
 			} else {
-				check_right_type_first_for_left_short_enum = true
+				check_right_type_first = true
 			}
 		}
 	}
+	if !check_right_type_first && c.expected_type == ast.void_type
+		&& operand_is_value_match_or_if(node.left) {
+		// A `match`/`if` value operand on the left, e.g. `(match x { ... }) + 1`,
+		// would otherwise be checked with the (void) surrounding expected type and
+		// mistyped as a statement (e.g. when nested inside an if-branch). Resolve
+		// the right operand's type first and use it as the expected type so the
+		// left operand is checked as a value expression.
+		check_right_type_first = true
+	}
 	mut right_type := ast.void_type
-	if check_right_type_first_for_left_short_enum {
+	if check_right_type_first {
 		right_type = c.expr(mut node.right)
 		if right_type == ast.no_type {
 			node.right_type = right_type
@@ -229,7 +238,7 @@ fn (mut c Checker) infix_expr(mut node ast.InfixExpr) ast.Type {
 			}
 		}
 	}
-	if !check_right_type_first_for_left_short_enum {
+	if !check_right_type_first {
 		right_type = c.expr(mut node.right)
 		if right_type == ast.no_type {
 			node.right_type = right_type

vlib/v/gen/c/cgen.v

@@ -13976,6 +13976,9 @@ fn as_cast_operand_needs_tmp_eval(expr ast.Expr) bool {
 		ast.ParExpr {
 			as_cast_operand_needs_tmp_eval(expr.expr)
 		}
+		ast.UnsafeExpr {
+			as_cast_operand_needs_tmp_eval(expr.expr)
+		}
 		ast.SelectorExpr {
 			as_cast_operand_needs_tmp_eval(expr.expr)
 		}

vlib/v/parser/parser.v

@@ -578,70 +578,131 @@ fn (mut p Parser) parse_block_no_scope(is_top_level bool) []ast.Stmt {
 }
 
 fn (mut p Parser) mark_last_call_return_as_used(mut last_stmt ast.Stmt) {
-	match mut last_stmt {
-		ast.ExprStmt {
-			match mut last_stmt.expr {
-				ast.CallExpr {
-					// last stmt on block is CallExpr
-					last_stmt.expr.is_return_used = true
-					if last_stmt.expr.or_block.stmts.len > 0 {
-						mut or_block_last_stmt := last_stmt.expr.or_block.stmts.last()
-						p.mark_last_call_return_as_used(mut or_block_last_stmt)
-					}
+	if mut last_stmt is ast.ExprStmt {
+		p.mark_last_call_expr_return_as_used(mut last_stmt.expr)
+	}
+}
+
+// expr_contains_value_match_or_if reports whether an expression is (or, through
+// transparent `(...)`/`unsafe { }`/cast/`as`-cast wrappers and nested call
+// arguments, contains) a `match`/`if` value expression. Used to decide whether a
+// call argument holds a block-value match/if whose arm calls must be marked as
+// return-used, including nested compositions like `wrap(wrap(match value { .. }))`.
+fn (p &Parser) expr_contains_value_match_or_if(expr ast.Expr) bool {
+	return match expr {
+		ast.MatchExpr, ast.IfExpr {
+			true
+		}
+		ast.ParExpr {
+			p.expr_contains_value_match_or_if(expr.expr)
+		}
+		ast.UnsafeExpr {
+			p.expr_contains_value_match_or_if(expr.expr)
+		}
+		ast.CastExpr {
+			p.expr_contains_value_match_or_if(expr.expr)
+		}
+		ast.AsCast {
+			p.expr_contains_value_match_or_if(expr.expr)
+		}
+		ast.CallExpr {
+			mut found := false
+			for arg in expr.args {
+				if p.expr_contains_value_match_or_if(arg.expr) {
+					found = true
+					break
 				}
-				ast.ConcatExpr {
-					// last stmt on block is: a, b, c := ret1(), ret2(), ret3()
-					for mut expr in last_stmt.expr.vals {
-						if mut expr is ast.CallExpr {
-							expr.is_return_used = true
-						}
-					}
+			}
+			found
+		}
+		ast.InfixExpr {
+			// e.g. `1 + (match value { .. })` as a call argument.
+
+			p.expr_contains_value_match_or_if(expr.left)
+				|| p.expr_contains_value_match_or_if(expr.right)
+		}
+		else {
+			false
+		}
+	}
+}
+
+fn (mut p Parser) mark_last_call_expr_return_as_used(mut expr ast.Expr) {
+	match mut expr {
+		ast.CallExpr {
+			// last stmt on block is CallExpr
+			expr.is_return_used = true
+			if expr.or_block.stmts.len > 0 {
+				mut or_block_last_stmt := expr.or_block.stmts.last()
+				p.mark_last_call_return_as_used(mut or_block_last_stmt)
+			}
+			// an argument may itself be (or nest) a block-value match/if, e.g.
+			// `wrap(match value { First { foo()! } })` or
+			// `wrap(wrap(match value { .. }))`; mark its arm calls too.
+			for mut arg in expr.args {
+				if p.expr_contains_value_match_or_if(arg.expr) {
+					p.mark_last_call_expr_return_as_used(mut arg.expr)
 				}
-				ast.IfExpr {
-					// last stmt on block is: if .. { foo() } else { bar() }
-					for mut branch in last_stmt.expr.branches {
-						if branch.stmts.len > 0 {
-							mut last_if_stmt := branch.stmts.last()
-							p.mark_last_call_return_as_used(mut last_if_stmt)
-						}
-					}
+			}
+		}
+		ast.ConcatExpr {
+			// last stmt on block is: a, b, c := ret1(), ret2(), ret3()
+			for mut val in expr.vals {
+				if mut val is ast.CallExpr {
+					val.is_return_used = true
 				}
-				ast.InfixExpr {
-					if last_stmt.expr.or_block.stmts.len > 0 {
-						mut or_block_last_stmt := last_stmt.expr.or_block.stmts.last()
-						p.mark_last_call_return_as_used(mut or_block_last_stmt)
-					}
-					// last stmt has infix expr with CallExpr: foo()? + 'a'
-					mut left_expr := last_stmt.expr.left
-					for {
-						mut next_left_expr := ast.Expr(ast.EmptyExpr{})
-						if mut left_expr is ast.InfixExpr {
-							if left_expr.or_block.stmts.len > 0 {
-								mut or_block_last_stmt := left_expr.or_block.stmts.last()
-								p.mark_last_call_return_as_used(mut or_block_last_stmt)
-							}
-							next_left_expr = left_expr.left
-						} else if mut left_expr is ast.CallExpr {
-							left_expr.is_return_used = true
-							if left_expr.or_block.stmts.len > 0 {
-								mut or_block_last_stmt := left_expr.or_block.stmts.last()
-								p.mark_last_call_return_as_used(mut or_block_last_stmt)
-							}
-							break
-						} else {
-							break
-						}
-						left_expr = next_left_expr
-						continue
-					}
+			}
+		}
+		ast.ParExpr {
+			// last stmt on block is parenthesized: ( match .. { a { foo() } } )
+			p.mark_last_call_expr_return_as_used(mut expr.expr)
+		}
+		ast.UnsafeExpr {
+			// last stmt on block is unsafe-wrapped: unsafe { match .. { a { foo() } } }
+			p.mark_last_call_expr_return_as_used(mut expr.expr)
+		}
+		ast.CastExpr {
+			// last stmt on block is cast-wrapped: i64(match .. { a { foo() } })
+			p.mark_last_call_expr_return_as_used(mut expr.expr)
+		}
+		ast.AsCast {
+			// last stmt on block is as-cast-wrapped: (match .. { a { foo() } }) as T
+			p.mark_last_call_expr_return_as_used(mut expr.expr)
+		}
+		ast.IfExpr {
+			// last stmt on block is: if .. { foo() } else { bar() }
+			for mut branch in expr.branches {
+				if branch.stmts.len > 0 {
+					mut last_if_stmt := branch.stmts.last()
+					p.mark_last_call_return_as_used(mut last_if_stmt)
 				}
-				ast.ComptimeCall, ast.ComptimeSelector, ast.PrefixExpr, ast.SelectorExpr {
-					if last_stmt.expr.or_block.stmts.len > 0 {
-						mut or_block_last_stmt := last_stmt.expr.or_block.stmts.last()
-						p.mark_last_call_return_as_used(mut or_block_last_stmt)
-					}
+			}
+		}
+		ast.MatchExpr {
+			// last stmt on block is: match .. { a { foo() } b { bar() } }
+			for mut branch in expr.branches {
+				if branch.stmts.len > 0 {
+					mut last_match_stmt := branch.stmts.last()
+					p.mark_last_call_return_as_used(mut last_match_stmt)
 				}
-				else {}
+			}
+		}
+		ast.InfixExpr {
+			if expr.or_block.stmts.len > 0 {
+				mut or_block_last_stmt := expr.or_block.stmts.last()
+				p.mark_last_call_return_as_used(mut or_block_last_stmt)
+			}
+			// last stmt has infix expr with value operands, e.g.
+			// `foo()? + 'a'` or `1 + (match value { First { bar()! } })`.
+			// Recurse into both sides so nested/wrapped match/if/call values on
+			// either operand are marked as return-used.
+			p.mark_last_call_expr_return_as_used(mut expr.left)
+			p.mark_last_call_expr_return_as_used(mut expr.right)
+		}
+		ast.ComptimeCall, ast.ComptimeSelector, ast.PrefixExpr, ast.SelectorExpr {
+			if expr.or_block.stmts.len > 0 {
+				mut or_block_last_stmt := expr.or_block.stmts.last()
+				p.mark_last_call_return_as_used(mut or_block_last_stmt)
 			}
 		}
 		else {}