fix: heap-allocate interface values in array/variadic contexts

When casting lvalues to interface types inside array literals or
variadic argument packing, the generated C code used stack pointers
(&local_var) for the interface object. These pointers become dangling
when the stack frame ends, causing parameter corruption on Linux
(confirmed on CI: string values read as empty or pointed to wrong
stack data like the query string).

Fix: set inside_cast_in_heap when generating interface/sumtype array
elements and variadic args so that call_cfn_for_casting_expr uses
HEAP() instead of bare &. This does not affect direct interface
assignments (mut ii := II(aa)) which correctly share memory.

Fixes #26760

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: vincenzopalazzo

vlib/v/gen/c/array.v

@@ -59,6 +59,9 @@ fn (mut g Gen) array_init(node ast.ArrayInit, var_name string) {
 			g.write('\t\t')
 		}
 		is_iface_or_sumtype := elem_sym.kind in [.sum_type, .interface]
+		if is_iface_or_sumtype {
+			g.inside_cast_in_heap++
+		}
 		for i, expr in node.exprs {
 			expr_type := if node.expr_types.len > i { node.expr_types[i] } else { node.elem_type }
 			if expr_type == ast.string_type
@@ -91,6 +94,9 @@ fn (mut g Gen) array_init(node ast.ArrayInit, var_name string) {
 				}
 			}
 		}
+		if is_iface_or_sumtype {
+			g.inside_cast_in_heap--
+		}
 		g.write('}))')
 		if g.is_shared {
 			g.write('}, sizeof(${shared_styp}))')

vlib/v/gen/c/cgen.v

@@ -3143,10 +3143,17 @@ fn (mut g Gen) call_cfn_for_casting_expr(fname string, expr ast.Expr, exp ast.Ty
 			false
 		}
 
+		// When casting an lvalue to an interface inside an array context
+		// (e.g. variadic args, array init), the interface stores a pointer
+		// that may outlive the source variable. Heap-allocate to prevent
+		// dangling pointers. (fixes #26760)
+		is_interface_in_heap_context := fname.contains('_to_Interface_')
+			&& g.inside_cast_in_heap > 0
+
 		if !is_cast_fixed_array_init && (is_comptime_variant || !expr.is_lvalue()
 			|| (expr is ast.Ident && (expr.obj.is_simple_define_const()
 			|| (expr.obj is ast.Var && expr.obj.is_index_var)))
-			|| is_primitive_to_interface || is_fn_arg) {
+			|| is_primitive_to_interface || is_fn_arg || is_interface_in_heap_context) {
 			// Note: the `_to_sumtype_` family of functions do call memdup internally, making
 			// another duplicate with the HEAP macro is redundant, so use ADDR instead:
 			if expr.is_as_cast() {

vlib/v/gen/c/fn.v

@@ -2862,6 +2862,11 @@ fn (mut g Gen) call_args(node ast.CallExpr) {
 							g.writeln('${g.styp(varg_type)} ${tmp_var};')
 							g.write('builtin___option_ok((${base_type}[]) {')
 						}
+						elem_sym := g.table.sym(arr_info.elem_type)
+						is_iface_or_sumtype := elem_sym.kind in [.sum_type, .interface]
+						if is_iface_or_sumtype {
+							g.inside_cast_in_heap++
+						}
 						g.write('builtin__new_array_from_c_array${noscan}(${variadic_count}, ${variadic_count}, sizeof(${elem_type}), _MOV((${elem_type}[${variadic_count}]){')
 						for j in arg_nr .. args.len {
 							g.ref_or_deref_arg(args[j], arr_info.elem_type, node.language,
@@ -2871,6 +2876,9 @@ fn (mut g Gen) call_args(node ast.CallExpr) {
 							}
 						}
 						g.write('}))')
+						if is_iface_or_sumtype {
+							g.inside_cast_in_heap--
+						}
 						if is_option {
 							g.writeln(' }, (${option_name}*)&${tmp_var}, sizeof(${base_type}));')
 							g.write(tmp)