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 {} }`
+	force_value_match_or_if     bool        // force a value `match`/`if` in a value-required void context (array element, map value, prefix operand) to be an expression, e.g. `[match x {..}]`, `{'k': match x {..}}`, `-(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)`
@@ -3080,7 +3081,19 @@ fn (mut c Checker) selector_expr(mut node ast.SelectorExpr) ast.Type {
 	node.is_field_typ = node.is_field_typ || c.comptime.is_comptime_selector_type(node)
 	old_selector_expr := c.inside_selector_expr
 	c.inside_selector_expr = true
+	// A value `match`/`if` selector receiver, e.g. `(match x { ... }).field`, in a
+	// void context (nested in an if-branch) must be checked as an expression so its
+	// arms produce values, instead of being typed `void` ("does not return a value").
+	mut restore_force_value := false
+	if c.expected_type == ast.void_type && !c.force_value_match_or_if
+		&& operand_is_value_match_or_if(node.expr) {
+		c.force_value_match_or_if = true
+		restore_force_value = true
+	}
 	mut typ := c.expr(mut node.expr)
+	if restore_force_value {
+		c.force_value_match_or_if = false
+	}
 	expr_is_auto_deref_var := node.expr.is_auto_deref_var()
 	receiver_uses_wrapped_smartcast := typ.has_option_or_result()
 		|| c.table.sym(c.unwrap_generic(typ)).kind in [.interface, .sum_type, .any]
@@ -4867,7 +4880,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 {
@@ -5281,7 +5305,19 @@ pub fn (mut c Checker) expr(mut node ast.Expr) ast.Type {
 			return c.unsafe_expr(mut node)
 		}
 		ast.Likely {
+			// A value `match`/`if` operand, e.g. `_likely_(match x { ... })`, in a
+			// void context (nested in an if-branch) must be checked as an expression
+			// so its arms produce values, instead of being typed `void`.
+			mut restore_force_value := false
+			if c.expected_type == ast.void_type && !c.force_value_match_or_if
+				&& operand_is_value_match_or_if(node.expr) {
+				c.force_value_match_or_if = true
+				restore_force_value = true
+			}
 			ltype := c.expr(mut node.expr)
+			if restore_force_value {
+				c.force_value_match_or_if = false
+			}
 			if !c.check_types(ltype, ast.bool_type) {
 				ltype_sym := c.table.sym(ltype)
 				lname := if node.is_likely { '_likely_' } else { '_unlikely_' }
@@ -5414,6 +5450,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 +5507,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
@@ -6932,7 +6992,19 @@ fn (mut c Checker) check_known_struct_name(ident ast.Ident) ? {
 fn (mut c Checker) concat_expr(mut node ast.ConcatExpr) ast.Type {
 	mut mr_types := []ast.Type{}
 	for mut expr in node.vals {
+		// A value `match`/`if` multi-return value, e.g. `match x { ... }, 9`, in a
+		// void context (nested in an if-branch) must be checked as an expression so
+		// its arms produce values, instead of being typed `void`.
+		mut restore_force_value := false
+		if c.expected_type == ast.void_type && !c.force_value_match_or_if
+			&& operand_is_value_match_or_if(expr) {
+			c.force_value_match_or_if = true
+			restore_force_value = true
+		}
 		mut typ := c.expr(mut expr)
+		if restore_force_value {
+			c.force_value_match_or_if = false
+		}
 		if typ == ast.nil_type {
 			// nil and voidptr produces the same struct type name
 			typ = ast.voidptr_type
@@ -7903,7 +7975,19 @@ fn (mut c Checker) get_base_name(node &ast.Expr) string {
 fn (mut c Checker) prefix_expr(mut node ast.PrefixExpr) ast.Type {
 	old_inside_ref_lit := c.inside_ref_lit
 	c.inside_ref_lit = c.inside_ref_lit || node.op == .amp
+	// A value `match`/`if` prefix operand, e.g. `-(match x { ... })`, in a void
+	// context (nested in an if-branch) must be checked as an expression so its arms
+	// produce values, instead of being typed `void` ("value after `-` is void").
+	mut restore_force_value := false
+	if c.expected_type == ast.void_type && !c.force_value_match_or_if
+		&& operand_is_value_match_or_if(node.right) {
+		c.force_value_match_or_if = true
+		restore_force_value = true
+	}
 	right_type := c.expr(mut node.right)
+	if restore_force_value {
+		c.force_value_match_or_if = false
+	}
 	c.inside_ref_lit = old_inside_ref_lit
 	node.right_type = right_type
 	mut expr := node.right
@@ -8459,12 +8543,33 @@ fn (mut c Checker) index_expr(mut node ast.IndexExpr) ast.Type {
 		}
 	}
 	if mut node.index is ast.RangeExpr { // [1..2]
+		// A value `match`/`if` range bound, e.g. `values[(match x { ... })..]`, in a
+		// void context (nested in an if-branch) must be checked as an expression so
+		// its arms produce values, instead of being typed `void`.
 		if node.index.has_low {
+			mut restore_low := false
+			if c.expected_type == ast.void_type && !c.force_value_match_or_if
+				&& operand_is_value_match_or_if(node.index.low) {
+				c.force_value_match_or_if = true
+				restore_low = true
+			}
 			index_type := c.expr(mut node.index.low)
+			if restore_low {
+				c.force_value_match_or_if = false
+			}
 			c.check_index(typ_sym, node.index.low, index_type, true, node.is_gated)
 		}
 		if node.index.has_high {
+			mut restore_high := false
+			if c.expected_type == ast.void_type && !c.force_value_match_or_if
+				&& operand_is_value_match_or_if(node.index.high) {
+				c.force_value_match_or_if = true
+				restore_high = true
+			}
 			index_type := c.expr(mut node.index.high)
+			if restore_high {
+				c.force_value_match_or_if = false
+			}
 			c.check_index(typ_sym, node.index.high, index_type, true, node.is_gated)
 		}
 		// array[1..2] => array
@@ -8509,7 +8614,20 @@ fn (mut c Checker) index_expr(mut node ast.IndexExpr) ast.Type {
 				c.warn('`or {}` block required when indexing a map with sum type value', node.pos)
 			}
 		} else {
+			// A value `match`/`if` index, e.g. `values[match x { ... }]`, in a void
+			// context (nested in an if-branch) must be checked as an expression so
+			// its arms produce values, instead of being typed `void` ("non-integer
+			// index `void`").
+			mut restore_force_value := false
+			if c.expected_type == ast.void_type && !c.force_value_match_or_if
+				&& operand_is_value_match_or_if(node.index) {
+				c.force_value_match_or_if = true
+				restore_force_value = true
+			}
 			index_type := c.expr(mut node.index)
+			if restore_force_value {
+				c.force_value_match_or_if = false
+			}
 			if node.is_gated && (typ.is_ptr() || typ.is_pointer()
 				|| typ_sym.kind !in [.array, .array_fixed, .string]) {
 				c.error('`#[]` negative indexing is only supported for arrays, fixed arrays, and strings',

vlib/v/checker/containers.v

@@ -409,8 +409,20 @@ fn (mut c Checker) array_init(mut node ast.ArrayInit) ast.Type {
 	}
 
 	if node.has_update_expr {
-		// `[...base, e1, e2]` — array update/spread literal
+		// `[...base, e1, e2]` — array update/spread literal.
+		// A value `match`/`if` spread operand, e.g. `[...(match x { ... })]`, in a
+		// void context (nested in an if-branch) must be checked as an expression so
+		// its arms produce values, instead of being typed `void`.
+		mut restore_force_value := false
+		if c.expected_type == ast.void_type && !c.force_value_match_or_if
+			&& operand_is_value_match_or_if(node.update_expr) {
+			c.force_value_match_or_if = true
+			restore_force_value = true
+		}
 		update_typ := c.expr(mut node.update_expr)
+		if restore_force_value {
+			c.force_value_match_or_if = false
+		}
 		// Resolve through type aliases so `type Ints = []int; [...Ints(...)]`
 		// is accepted; use final_sym to look past aliases of arrays.
 		update_sym := c.table.final_sym(update_typ)
@@ -507,7 +519,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.force_value_match_or_if
+					&& operand_is_value_match_or_if(expr) {
+					c.force_value_match_or_if = 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.force_value_match_or_if = false
+				}
 				sym := c.table.sym(expected_value_type)
 				if sym.kind == .interface {
 					c.type_implements(typ, expected_value_type, expr.pos())
@@ -911,7 +938,19 @@ fn (mut c Checker) map_init(mut node ast.MapInit) ast.Type {
 			map_type = c.expected_type
 		}
 		if node.has_update_expr {
+			// A value `match`/`if` map update operand, e.g. `{ ...(match x { .. }), k: v }`,
+			// in a void context must be checked as an expression so its arms produce
+			// values, instead of being typed `void` ("non-map type").
+			mut restore_force_value := false
+			if map_type == ast.void_type && c.expected_type == ast.void_type
+				&& !c.force_value_match_or_if && operand_is_value_match_or_if(node.update_expr) {
+				c.force_value_match_or_if = true
+				restore_force_value = true
+			}
 			update_type := c.expr(mut node.update_expr)
+			if restore_force_value {
+				c.force_value_match_or_if = false
+			}
 			if map_type != ast.void_type {
 				if update_type != map_type {
 					msg := c.expected_msg(update_type, map_type)
@@ -934,12 +973,39 @@ fn (mut c Checker) map_init(mut node ast.MapInit) ast.Type {
 		} else if node.keys.len > 0 {
 			// `{'age': 20}`
 			mut key_ := node.keys[0]
+			// A value `match`/`if` map key, e.g. `{(match x { ... }): v}`, in a void
+			// context determines the map key type and must be checked as an
+			// expression (like the value below). Same flag mechanism.
+			mut restore_key_flag := false
+			if c.expected_type == ast.void_type && !c.force_value_match_or_if
+				&& operand_is_value_match_or_if(key_) {
+				c.force_value_match_or_if = true
+				restore_key_flag = true
+			}
 			map_key_type = ast.mktyp(c.expr(mut key_))
+			if restore_key_flag {
+				c.force_value_match_or_if = false
+			}
 			if node.keys[0].is_auto_deref_var() {
 				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.force_value_match_or_if
+				&& operand_is_value_match_or_if(val_) {
+				c.force_value_match_or_if = true
+				restore_container_flag = true
+			}
 			map_val_type = ast.mktyp(c.expr(mut val_))
+			if restore_container_flag {
+				c.force_value_match_or_if = 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 value-required flag so it applies only to this outer node, not to
+	// nested statement-level match/if inside the branches. A value `if` in a
+	// value-required void context (`[if ...]`, `{'k': if ...}`, `-(if ...)`) must
+	// still be treated as an expression.
+	force_value := c.force_value_match_or_if
+	c.force_value_match_or_if = 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 force_value {
+			node_is_expr = true
 		}
 	}
 	if c.expected_type == ast.void_type && node_is_expr {

vlib/v/checker/infix.v

@@ -113,20 +113,20 @@ 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
 			}
 		}
 	}
 	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
@@ -135,7 +135,22 @@ fn (mut c Checker) infix_expr(mut node ast.InfixExpr) ast.Type {
 		node.right_type = right_type
 		c.expected_type = right_type
 	}
+	// A `match`/`if` value operand on the left, e.g. `(match x { ... }) + 1` or
+	// `(match x { ... }) in [1, 2]`, would otherwise be checked with the (void)
+	// surrounding expected type and mistyped as a statement (e.g. when nested inside
+	// an if-branch). Force it to be checked as a value expression so its arms infer
+	// their own type, without imposing the right operand's type (which for a
+	// membership operator is a container, not the element/key type).
+	mut restore_force_value := false
+	if !check_right_type_first && c.expected_type == ast.void_type && !c.force_value_match_or_if
+		&& operand_is_value_match_or_if(node.left) {
+		c.force_value_match_or_if = true
+		restore_force_value = true
+	}
 	mut left_type := c.expr(mut node.left)
+	if restore_force_value {
+		c.force_value_match_or_if = false
+	}
 	if left_type == ast.no_type {
 		node.left_type = left_type
 		return ast.void_type
@@ -229,7 +244,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