cgen: fix fn arg for struct nested fields (fix #26346) (#26349)

Author: kbkpbot

vlib/v/ast/ast.v

@@ -2483,6 +2483,31 @@ pub fn (expr Expr) is_lvalue() bool {
 	}
 }
 
+// Helper function to check if an expression ultimately refers to a function argument
+// This handles cases like `p.s`, `p.inner.data`, etc. where `p` is a function argument
+pub fn (expr Expr) is_fn_arg() bool {
+	return match expr {
+		Ident {
+			if expr.obj is Var {
+				expr.obj.is_arg
+			} else {
+				false
+			}
+		}
+		SelectorExpr {
+			// Recursively check if the base expression is a function argument
+			expr.expr.is_fn_arg()
+		}
+		IndexExpr {
+			// Array indexing like `arr[0]` - check if `arr` is a function argument
+			expr.left.is_fn_arg()
+		}
+		else {
+			false
+		}
+	}
+}
+
 pub fn (expr Expr) is_expr() bool {
 	return match expr {
 		IfExpr, LockExpr, MatchExpr, SelectExpr { expr.is_expr }

vlib/v/gen/c/cgen.v

@@ -2986,18 +2986,19 @@ fn (mut g Gen) call_cfn_for_casting_expr(fname string, expr ast.Expr, exp ast.Ty
 			&& g.table.sym(got).kind in [.i8, .i16, .i32, .int, .i64, .isize, .u8, .u16, .u32, .u64, .usize, .f32, .f64, .bool, .rune]
 
 		// Check if the expression is a function argument (local variable) that needs heap allocation
-		is_fn_arg := if expr is ast.Ident && expr.obj is ast.Var {
-			expr.obj.is_arg
-		} else {
-			false
-		}
+		is_fn_arg := expr.is_fn_arg()
 
 		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) {
 			// Note: the `_to_sumtype_` family of functions do call memdup internally, making
-			// another duplicate with the HEAP macro is redundant, so use ADDR instead:
+			// another duplicate with the HEAP macro is redundant, so use ADDR instead.
+			// However, this only applies when the expression is a simple Ident that we can
+			// easily declare a temporary variable for. For SelectorExpr and IndexExpr, we
+			// cannot use ADDR because it requires a temporary variable declaration.
+			// For sumtype casts with SelectorExpr or IndexExpr, we should not use any macro
+			// because the sumtype casting function already handles memory allocation.
 			if expr.is_as_cast() {
 				if !got_is_ptr && expr is ast.SelectorExpr {
 					// (var as Type).field_non_ptr
@@ -3008,8 +3009,15 @@ fn (mut g Gen) call_cfn_for_casting_expr(fname string, expr ast.Expr, exp ast.Ty
 				defer(fn) {
 					g.inside_smartcast = old_inside_smartcast
 				}
+			} else if is_sumtype_cast && is_fn_arg && expr !is ast.Ident {
+				// For sumtype casts with SelectorExpr or IndexExpr, don't use any macro
+				// because the sumtype casting function already handles memory allocation
+				// and we cannot use ADDR for these expression types.
+				// Just take the address of the expression since the function expects a pointer.
+				g.write('&(')
+				rparen_n++
 			} else {
-				promotion_macro_name := if is_sumtype_cast { 'ADDR' } else { 'HEAP' }
+				promotion_macro_name := if is_sumtype_cast && is_fn_arg { 'ADDR' } else { 'HEAP' }
 				g.write('${promotion_macro_name}(${got_styp}, (')
 				rparen_n += 2
 			}

vlib/v/tests/interface_nested_field_ref_arg_test.v

@@ -0,0 +1,51 @@
+module main
+
+import arrays
+
+interface Value {}
+
+struct Inner {
+	data string
+}
+
+struct Outer {
+	inner Inner
+}
+
+struct WithArray {
+	items []string
+}
+
+fn nested_struct_field(p Outer) []Value {
+	mut params := []Value{}
+	if p.inner.data != '' {
+		params = arrays.concat(params, p.inner.data)
+	}
+	return params
+}
+
+fn array_index_field(p WithArray) []Value {
+	mut params := []Value{}
+	if p.items.len > 0 {
+		params = arrays.concat(params, p.items[0])
+	}
+	return params
+}
+
+fn test_interface_nested_field_ref_arg() {
+	outer := Outer{
+		inner: Inner{
+			data: 'nested data'
+		}
+	}
+	params := nested_struct_field(outer)
+	assert params == [Value('nested data')]
+}
+
+fn test_interface_array_index_ref_arg() {
+	wa := WithArray{
+		items: ['first', 'second']
+	}
+	params := array_index_field(wa)
+	assert params == [Value('first')]
+}

vlib/v/tests/interface_struct_field_ref_arg_test.v

@@ -0,0 +1,29 @@
+module main
+
+import arrays
+
+interface Value {}
+
+struct SomeStruct {
+	s string
+}
+
+fn generate_params(p SomeStruct) (string, []Value) {
+	mut conditions := []string{}
+	mut params := []Value{}
+
+	if p.s != '' {
+		conditions = arrays.concat(conditions, 'email = ?')
+		params = arrays.concat(params, p.s)
+	}
+
+	return conditions.join('AND '), params
+}
+
+fn test_interface_struct_field_ref_arg() {
+	str, params := generate_params(SomeStruct{
+		s: 'some string'
+	})
+	assert str == 'email = ?'
+	assert params == [Value('some string')]
+}