cgen: fix sumtype string-rvalue cast, ?&T == nil unwrap, and generic default interface field

Fixes three cgen bugs:

- #27548: casting a string rvalue (slice `s[a..b]` or concat) into a sumtype
  emitted `&<rvalue>`, which strict C compilers reject. `is_lvalue()` reports a
  slice as an lvalue, so the cast took a bare address instead of materializing
  it. Treat a slice as an rvalue so the sumtype cast uses the ADDR macro.

- #27549: unwrapping an option-of-pointer field (`?&T`) via a `== nil`/`== none`
  check emitted one too many dereferences (`**(T**)(data)` instead of
  `*(T**)(data)`). The single-deref path was gated on `g.left_is_opt`, which is
  only set in the smartcast (`:=`) form. The option's `.data` buffer holds a
  single `&T`, so one deref is always correct for `?&T`, independent of that flag.

- #27550: a generic struct used as the default value of an interface-typed field
  in a generic wrapper left a leftover unresolved-generic variant (`Text[T]`) in
  the interface's types list, which the interface auto-str dispatch emitted as
  broken C (`Text_T_T`, undeclared `_..._index`). Skip unresolved-generic struct
  variants in gen_str_for_interface, mirroring the existing skip in
  interface_table(). The struct init itself already monomorphizes correctly.

Author: medvednikov

vlib/v/gen/c/auto_str_methods.v

@@ -439,6 +439,15 @@ fn (mut g Gen) gen_str_for_interface(info ast.Interface, styp string, typ_str st
 	fn_builder.writeln('${g.static_non_parallel}string indent_${str_fn_name}(${styp} x, ${ast.int_type_name} indent_count) { /* gen_str_for_interface */')
 	fn_builder.writeln('\tif (x._typ == 0 && x._object == NULL) return _S("nil");')
 	for typ in info.types {
+		// Skip unresolved generic struct variants (e.g. a leftover `Text[T]`
+		// registered when a generic struct is used as the default value of an
+		// interface-typed field in a generic wrapper). Only their concrete
+		// instantiations (`Text[int]`) are real runtime variants. This mirrors
+		// the same skip in interface_table().
+		type_sym := g.table.sym(typ)
+		if type_sym.info is ast.Struct && type_sym.info.is_unresolved_generic() {
+			continue
+		}
 		sub_sym := g.table.sym(ast.mktyp(typ))
 		if g.pref.skip_unused && sub_sym.idx !in g.table.used_features.used_syms {
 			continue

vlib/v/gen/c/cgen.v

@@ -5174,7 +5174,10 @@ fn (mut g Gen) call_cfn_for_casting_expr(fname string, expr ast.Expr, exp ast.Ty
 	} else if is_interface_cast {
 		interface_cast_source_expr.is_lvalue()
 	} else {
-		expr.is_lvalue()
+		// 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_comptime_variant := is_not_ptr_and_fn && expr is ast.Ident
 		&& g.comptime.is_comptime_variant_var(expr)
@@ -7984,8 +7987,13 @@ fn (mut g Gen) selector_expr(node ast.SelectorExpr) {
 					for i, typ in smartcasts {
 						if i == 0 && (is_option_unwrap || nested_unwrap) {
 							deref := if g.inside_selector {
-								if is_iface_or_sumtype || (field.orig_type.is_ptr() && g.left_is_opt
-									&& is_option_unwrap) {
+								if is_iface_or_sumtype
+									|| (field.orig_type.is_ptr() && is_option_unwrap) {
+									// Unwrapping an option-of-pointer field (`?&T`): the
+									// option's `.data` buffer holds a single `&T`, so one
+									// deref of the `(T**)` cast yields the pointer. This must
+									// hold for every unwrap form (smartcast `:=`, `== nil`,
+									// `== none`), independent of `g.left_is_opt`.
 									'*'.repeat(typ.nr_muls())
 								} else {
 									'*'.repeat(typ.nr_muls() + 1)

vlib/v/tests/casts/cast_string_rvalue_to_sumtype_test.v

@@ -0,0 +1,24 @@
+// Casting a string rvalue (a slice or a concatenation) into a sumtype must
+// materialize the rvalue into a temporary before taking its address, otherwise
+// cgen emits `&<rvalue>` which strict C compilers reject. See issue #27548.
+type Value = int | string
+
+fn slice(s string) Value {
+	return Value(s[1..3])
+}
+
+fn concat(a string, b string) Value {
+	return Value(a + b)
+}
+
+fn test_string_slice_cast_to_sumtype() {
+	v := 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
+	assert (v as string) == 'foobar'
+}

vlib/v/tests/generics/generic_struct_default_interface_field_test.v

@@ -0,0 +1,29 @@
+// A generic struct used as the default value of an interface-typed field inside
+// a generic wrapper must monomorphize with the wrapper's type argument, instead
+// of leaving the type parameter unresolved (`Text_T_T`). The leftover generic
+// variant must also not pollute the interface's auto-generated str().
+// See issue #27550.
+interface Tag {
+	tag() string
+}
+
+struct Text[T] {
+	val T
+}
+
+fn (t Text[T]) tag() string {
+	return 'text'
+}
+
+struct Wrapper[T] {
+	tag Tag = Text[T]{}
+}
+
+fn test_generic_struct_default_interface_field() {
+	w := Wrapper[int]{}
+	assert w.tag.tag() == 'text'
+	// stringifying the wrapper exercises the interface variant auto-str dispatch
+	s := w.str()
+	assert s.contains('Text[int]{')
+	assert s.contains('val: 0')
+}

vlib/v/tests/options/option_ptr_field_nil_check_unwrap_test.v

@@ -0,0 +1,42 @@
+// Unwrapping an option-of-pointer struct field (`?&T`) after a `== nil` /
+// `== none` check and accessing a member must emit a single dereference, the
+// same as the smartcast (`if p := ... {}`) form. The option's `.data` buffer
+// holds a single `&T`, so `*(T**)(data)` yields the pointer. See issue #27549.
+struct SessionNode {
+	id     string
+	parent ?&SessionNode
+}
+
+fn parent_id_nil_check(node &SessionNode) string {
+	return unsafe {
+		if node.parent == nil {
+			'root'
+		} else {
+			node.parent.id
+		}
+	}
+}
+
+fn parent_id_smartcast(node &SessionNode) string {
+	if p := node.parent {
+		return p.id
+	}
+	return 'root'
+}
+
+fn test_option_ptr_field_nil_check_unwrap() {
+	root := &SessionNode{
+		id: 'root-node'
+	}
+	child := &SessionNode{
+		id:     'child'
+		parent: root
+	}
+
+	// the `== nil` ternary form must agree with the smartcast form
+	assert parent_id_nil_check(child) == 'root-node'
+	assert parent_id_nil_check(root) == 'root'
+
+	assert parent_id_smartcast(child) == 'root-node'
+	assert parent_id_smartcast(root) == 'root'
+}