cgen: also materialize parenthesized string-slice sumtype casts via ADDR

The #27548 fix only treated a top-level `IndexExpr` with a `RangeExpr` as an
rvalue, but `ast.Expr.is_lvalue()` recurses through `ParExpr`, so a trivially
parenthesized slice (`Value((s[1..3]))`) still reported as an lvalue and took
the bare `&` path, reproducing the "address of an rvalue" C error.

Replace the inline top-level check with a small recursive helper that unwraps
parentheses, and add a regression test for the parenthesized form.

Author: medvednikov

vlib/v/gen/c/cgen.v

@@ -5153,6 +5153,17 @@ fn (mut g Gen) fn_ptr_cast_typ(func ast.FnType) string {
 	return g.fn_ptr_decl_str(func, ptr_name).replace_once(ptr_name, '')
 }
 
+// expr_is_range_index reports whether expr is a slice (`s[a..b]`), possibly
+// wrapped in parentheses. A slice yields a fresh rvalue with no stable address,
+// so it must be materialized via ADDR rather than `&` in a sumtype cast.
+fn expr_is_range_index(expr ast.Expr) bool {
+	return match expr {
+		ast.IndexExpr { expr.index is ast.RangeExpr }
+		ast.ParExpr { expr_is_range_index(expr.expr) }
+		else { false }
+	}
+}
+
 fn (mut g Gen) call_cfn_for_casting_expr(fname string, expr ast.Expr, exp ast.Type, got ast.Type, actual_got ast.Type, exp_styp string,
 	got_is_ptr bool, got_is_fn bool, got_styp string) {
 	mut rparen_n := 1
@@ -5177,7 +5188,9 @@ fn (mut g Gen) call_cfn_for_casting_expr(fname string, expr ast.Expr, exp ast.Ty
 		// A slice expression (`s[a..b]`) yields a fresh rvalue with no stable
 		// address, even though `is_lvalue()` reports it as one. Treat it as an
 		// rvalue so the sumtype cast materializes it via ADDR instead of `&`.
-		expr.is_lvalue() && !(expr is ast.IndexExpr && expr.index is ast.RangeExpr)
+		// `is_lvalue()` recurses through `ParExpr`, so unwrap parens too
+		// (`(s[a..b])`).
+		expr.is_lvalue() && !expr_is_range_index(expr)
 	}
 	is_comptime_variant := is_not_ptr_and_fn && expr is ast.Ident
 		&& g.comptime.is_comptime_variant_var(expr)

vlib/v/tests/casts/cast_string_rvalue_to_sumtype_test.v

@@ -7,6 +7,12 @@ fn slice(s string) Value {
 	return Value(s[1..3])
 }
 
+fn paren_slice(s string) Value {
+	// `is_lvalue()` recurses through parentheses, so a parenthesized slice must
+	// also be materialized via ADDR.
+	return Value((s[1..3]))
+}
+
 fn concat(a string, b string) Value {
 	return Value(a + b)
 }
@@ -17,6 +23,12 @@ fn test_string_slice_cast_to_sumtype() {
 	assert (v as string) == 'el'
 }
 
+fn test_string_paren_slice_cast_to_sumtype() {
+	v := paren_slice('hello')
+	assert v is string
+	assert (v as string) == 'el'
+}
+
 fn test_string_concat_cast_to_sumtype() {
 	v := concat('foo', 'bar')
 	assert v is string