ast, cgen: fix receiver methods on embedded interfaces (fix #19550)

[Macho0x]

This PR fixes the compiler error and incorrect runtime behavior when calling a receiver method (defined outside an interface) on an interface that embeds another interface.

Fixes #19550.

Problem

Given:

interface Node {
    name string
mut:
    children []&Node
}

fn (mut node Node) append_child(child &Node) {
    node.children << child
}

interface Element {
    Node
    attributes map[string]string
}

// HTMLBodyElement implements Element (and therefore Node)

Calling element.append_child(&Node(&Text{...})) on a value of type &Element failed with:

error: cannot implement interface Element with a different interface &Node

Even when the checker error was bypassed, the generated code reinterpreted the Element* interface struct as a Node*, leading to incorrect field offsets and broken runtime behavior.

Root cause

1. When an interface embeds another interface, new_method_with_receiver_type was rewriting self-referential parameters of concrete receiver methods to match the outer interface type. That made signatures such as fn (mut n Node) add(child &Node) appear to require &Element, which is wrong.

2. In cgen, calling a method inherited from an embedded interface used a raw pointer cast from the outer interface struct to the embedded interface struct. The two structs have different C layouts, so the cast read/wrote the wrong fields.

Fix

• vlib/v/ast/ast.v: new_method_with_receiver_type now only transforms self-referential parameters for interface method declarations (no_body == true). Concrete receiver methods keep their original parameter types.
• vlib/v/gen/c/fn.v: when the receiver is an interface and the method comes from an embedded interface, generate an interface-to-interface conversion (I_as_I) instead of a pointer cast. For mut receivers, the converted value is stored in a temporary whose address is passed to the method; the field pointers inside the temporary still refer to the original object, so mutations are visible.

Test
Added vlib/v/tests/interfaces/interface_receiver_method_on_embedded_interface_test.v, which exercises:

• a mut receiver method inherited from an embedded interface,
• passing a concrete value cast to the embedded interface as an argument,
• correct field access on both the outer and embedded interface after the call.

Verification

• Reproduction from V error with receiver method on interface #19550 now compiles and prints the expected output.
• vlib/v/tests/interfaces/ passes: 97 passed, 97 total.

[chatgpt-codex-connector]

Codex usage limits have been reached for code reviews. Please check with the admins of this repo to increase the limits by adding credits.

[medvednikov]

@codex review

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 439aa2bb35

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Drop stale ADDR wrapper before passing the temp receiver

When this embedded-interface method call is on a non-lvalue receiver (for example make_element().append_child(...)) or an interface smartcast, the receiver setup above has already emitted an ADDR(rec_cc_type, ... wrapper instead of a literal &. This branch only strips &, then writes &tmp, so the later cast_n close produces C like ADDR(EmbeddedIface, &tmp), wrapping a pointer where the macro expects an interface value and causing otherwise valid calls to fail to compile.

Useful? React with 👍 / 👎.