[jira] [Updated] (THRIFT-6198) CS0121 ambiguous extension methods generated for container types referencing included structs

["Jens Geyer (Jira)" <ji...@apache.org>]

     [ https://issues.apache.org/jira/browse/THRIFT-6198?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]

Jens Geyer updated THRIFT-6198:
-------------------------------
    Summary: CS0121 ambiguous extension methods generated for container types referencing included structs  (was: netstd: CS0121 ambiguous extension methods generated for container types referencing included structs)

> CS0121 ambiguous extension methods generated for container types referencing included structs
> ---------------------------------------------------------------------------------------------
>
>                 Key: THRIFT-6198
>                 URL: https://issues.apache.org/jira/browse/THRIFT-6198
>             Project: Thrift
>          Issue Type: Bug
>          Components: netstd - Compiler
>            Reporter: Sylwester Lachiewicz
>            Assignee: Jens Geyer
>            Priority: Major
>
> h3. Problem Description
> In {{t_netstd_generator.cc}}, {{collect_extensions_types(t_type* ttype)}} gathers types requiring generated extension methods ({{DeepCopy}}, {{Equals}}, {{GetHashCode}}).
> While struct recursion is guarded by a program-ownership check to prevent duplicate signatures (lines 750–758):
> {code:cpp}
> // Only recurse into structs defined in the current program. Structs from
> // included programs are processed by those programs' own generators, which
> // generate extension methods for their internal container types. Recursing
> // into them here would duplicate those extension method signatures (CS0121).
> if (ttype->get_program() == program_)
> {
>     t_struct* tstruct = static_cast<t_struct*>(ttype);
>     collect_extensions_types(tstruct);
> }
> {code}
> The container branch (lines 763–792) lacks an equivalent guard:
> {code:cpp}
> if (ttype->is_container())
> {
>     if( collected_extension_types.find(key) == collected_extension_types.end())
>     {
>         collected_extension_types[key] = ttype;   // prevent recursion
>         ...
> {code}
> When Program B includes Program A, and both programs define container types over a struct from Program A (or typedefs resolving to it):
> # {{ProgramA.Extensions.cs}} generates {{public static List<InnerStruct> DeepCopy(this List<InnerStruct> source)}}
> # {{ProgramB.Extensions.cs}} also generates {{public static List<InnerStruct> DeepCopy(this List<InnerStruct> source)}}
> If both programs share the default namespace (or are imported into the same scope / project), C# compilation fails with:
> {noformat}
> error CS0121: The call is ambiguous between the following methods or properties: 'ProgramAExtensions.DeepCopy(List<InnerStruct>)' and 'ProgramBExtensions.DeepCopy(List<InnerStruct>)'
> {noformat}
> h3. Steps to Reproduce
> 1. IDL A ({{TypedefStructTest.thrift}}):
> {code:thrift}
> struct InnerStruct { 1: string s }
> typedef InnerStruct InnerAlias
> struct Outer { 1: list<InnerAlias> inners }
> {code}
> 2. IDL B ({{TypedefIncludeTest.thrift}}):
> {code:thrift}
> include "TypedefStructTest.thrift"
> typedef TypedefStructTest.InnerStruct IncludedAlias
> struct HoldsIncluded { 1: list<IncludedAlias> values }
> {code}
> 3. Compile with {{--gen netstd}} and compile the resulting C# code into a single assembly/solution.
> h3. Expected Behavior
> Extension methods for container types should not be duplicated across included program extension classes, or container ownership should follow the program owning the underlying element type.



--
This message was sent by Atlassian Jira
(v8.20.10#820010)