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

vlib/v/checker/checker.v

@@ -108,6 +108,7 @@ pub mut:
 	inside_ct_attr              bool        // true inside `[if expr]`
 	inside_x_is_type            bool        // true inside the Type expression of `if x is Type {`
 	inside_x_matches_type       bool        // true inside the match branch of `match x.type { Type {} }`
+	inside_container_value_elem bool        // true when checking a value `match`/`if` array element or map value, e.g. `[match x { .. }]` / `{'k': match x { .. }}`
 	anon_struct_should_be_mut   bool        // true when `mut var := struct { ... }` is used
 	inside_generic_struct_init  bool
 	inside_integer_literal_cast bool // true inside `int(123)`
@@ -4867,7 +4868,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 +5426,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 +5483,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/containers.v

@@ -507,7 +507,22 @@ fn (mut c Checker) array_init(mut node ast.ArrayInit) ast.Type {
 						expr_pos)
 					continue
 				}
+				// A value `match`/`if` array element, e.g. `[match x { ... }]`, in a
+				// void context (e.g. nested in an if-branch) must be checked as an
+				// expression (`is_expr`) so its arms produce values and infer the
+				// element type, instead of being lowered as void statements. Signal
+				// that via a flag rather than a forced expected type, which would
+				// mistype the arms.
+				mut restore_array_elem_flag := false
+				if c.expected_type == ast.void_type && !c.inside_container_value_elem
+					&& operand_is_value_match_or_if(expr) {
+					c.inside_container_value_elem = true
+					restore_array_elem_flag = true
+				}
 				typ = c.check_expr_option_or_result_call(expr, c.expr(mut expr))
+				if restore_array_elem_flag {
+					c.inside_container_value_elem = false
+				}
 				sym := c.table.sym(expected_value_type)
 				if sym.kind == .interface {
 					c.type_implements(typ, expected_value_type, expr.pos())
@@ -939,7 +954,22 @@ fn (mut c Checker) map_init(mut node ast.MapInit) ast.Type {
 				map_key_type = map_key_type.deref()
 			}
 			mut val_ := node.vals[0]
+			// A value `match`/`if` map value, e.g. `{'k': match x { ... }}`, in a
+			// void context (e.g. nested in an if-branch) determines the map value
+			// type and must be checked as an expression (`is_expr`) so its arms
+			// produce values, instead of being lowered as void statements. Signal
+			// that via a flag (leaving the expected type void so the arms infer
+			// their own type), consumed by `match_expr`/`if_expr`.
+			mut restore_container_flag := false
+			if c.expected_type == ast.void_type && !c.inside_container_value_elem
+				&& operand_is_value_match_or_if(val_) {
+				c.inside_container_value_elem = true
+				restore_container_flag = true
+			}
 			map_val_type = ast.mktyp(c.expr(mut val_))
+			if restore_container_flag {
+				c.inside_container_value_elem = false
+			}
 			if node.vals[0].is_auto_deref_var() {
 				map_val_type = map_val_type.deref()
 			}

vlib/v/checker/if.v

@@ -115,13 +115,21 @@ fn (mut c Checker) gen_branch_context_string() string {
 
 fn (mut c Checker) if_expr(mut node ast.IfExpr) ast.Type {
 	if_kind := if node.is_comptime { '\$if' } else { 'if' }
+	// Consume the container-element value flag so it applies only to this outer
+	// node, not to nested statement-level match/if inside the branches. `[if ...]`
+	// or `{'k': if ...}` as a value element in a void context must still be treated
+	// as an expression.
+	is_container_value_elem := c.inside_container_value_elem
+	c.inside_container_value_elem = false
 	mut node_is_expr := false
 	if node.branches.len > 0 && node.has_else {
 		stmts := node.branches[0].stmts
 		if stmts.len > 0 && stmts.last() is ast.ExprStmt && stmts.last().typ != ast.void_type {
 			node_is_expr = true
 		} else if node.is_expr {
 			node_is_expr = true
+		} else if is_container_value_elem {
+			node_is_expr = true
 		}
 	}
 	if c.expected_type == ast.void_type && node_is_expr {

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/checker/match.v

@@ -6,8 +6,15 @@ import v.token
 import strings
 
 fn (mut c Checker) match_expr(mut node ast.MatchExpr) ast.Type {
+	// `c.inside_container_value_elem` marks a value match used as an array element
+	// or map value in a void context (`[match x { .. }]`, `{'k': match x { .. }}`),
+	// which must be treated as an expression even though the surrounding expected
+	// type is void. Consume the flag here so it applies only to this outer element
+	// node, not to nested statement-level match/if inside the arms.
+	is_container_value_elem := c.inside_container_value_elem
+	c.inside_container_value_elem = false
 	if !node.is_comptime {
-		node.is_expr = c.expected_type != ast.void_type
+		node.is_expr = c.expected_type != ast.void_type || is_container_value_elem
 	}
 	node.expected_type = c.expected_type
 	if mut node.cond is ast.ParExpr && !c.pref.translated && !c.file.is_translated {

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)
 		}