Fix handling if dictionary inferrence in source generator. (#8962)

Author: michaelstaib

src/HotChocolate/Core/src/Types.Analyzers/Helpers/TypeReferenceBuilder.cs

@@ -115,9 +115,8 @@ private static (string TypeStructure, string TypeDefinition, bool IsSimpleType)
             isNullable = false;
         }
 
-        if (underlyingType is INamedTypeSymbol namedType && IsListType(namedType))
+        if (underlyingType is INamedTypeSymbol namedType && TryGetListElementType(namedType, out var listElementType))
         {
-            var listElementType = namedType.TypeArguments[0];
             var (typeStructure, typeDefinition, _) = CreateTypeKey(listElementType);
 
             if (isNullable)
@@ -240,10 +239,13 @@ private static bool IsArrayType(ITypeSymbol namedType, [NotNullWhen(true)] out I
         return false;
     }
 
-    private static bool IsListType(INamedTypeSymbol namedType)
+    private static bool TryGetListElementType(
+        INamedTypeSymbol namedType,
+        [NotNullWhen(true)] out ITypeSymbol? elementType)
     {
         if (!namedType.IsGenericType)
         {
+            elementType = null;
             return false;
         }
 
@@ -254,10 +256,13 @@ private static bool IsListType(INamedTypeSymbol namedType)
         if (WellKnownTypes.ListInterfaceTypes.Contains(typeDefinition)
             || WellKnownTypes.ListClassTypes.Contains(typeDefinition))
         {
+            elementType = namedType.TypeArguments[0];
             return true;
         }
 
-        // Check if the type implements any of the known list interfaces
+        // Check if the type implements any of the known list interfaces.
+        // This handles cases like Dictionary<K,V> which implements IEnumerable<KeyValuePair<K,V>>.
+        // We extract the element type from the interface, not from the type's own type arguments.
         foreach (var interfaceType in namedType.AllInterfaces)
         {
             if (!interfaceType.IsGenericType)
@@ -268,6 +273,7 @@ private static bool IsListType(INamedTypeSymbol namedType)
             var interfaceDefinition = GetGenericTypeDefinition(interfaceType.OriginalDefinition);
             if (WellKnownTypes.ListInterfaceTypes.Contains(interfaceDefinition))
             {
+                elementType = interfaceType.TypeArguments[0];
                 return true;
             }
         }
@@ -285,12 +291,14 @@ private static bool IsListType(INamedTypeSymbol namedType)
             var baseDefinition = GetGenericTypeDefinition(currentType.OriginalDefinition);
             if (WellKnownTypes.ListClassTypes.Contains(baseDefinition))
             {
+                elementType = currentType.TypeArguments[0];
                 return true;
             }
 
             currentType = currentType.BaseType;
         }
 
+        elementType = null;
         return false;
     }
 

src/HotChocolate/Core/test/Types.Analyzers.Tests/CollectionInferenceTests.cs

@@ -0,0 +1,28 @@
+namespace HotChocolate.Types;
+
+public class CollectionInferenceTests
+{
+    [Fact]
+    public async Task Infer_Dictionary_As_List_Of_KeyValuePair()
+    {
+        await TestHelper.GetGeneratedSourceSnapshot(
+            """
+            using System;
+            using System.Collections.Generic;
+            using System.Threading;
+            using System.Threading.Tasks;
+            using HotChocolate;
+            using HotChocolate.Types;
+
+            namespace TestNamespace;
+
+            [QueryType]
+            internal static partial class Query
+            {
+                public static Task<Dictionary<int, string?>> GetStuffAsync(
+                    CancellationToken cancellationToken)
+                    => default;
+            }
+            """).MatchMarkdownAsync();
+    }
+}

src/HotChocolate/Core/test/Types.Analyzers.Tests/__snapshots__/CollectionInferenceTests.Infer_Dictionary_As_List_Of_KeyValuePair.md

@@ -0,0 +1,119 @@
+# Infer_Dictionary_As_List_Of_KeyValuePair
+
+## HotChocolateTypeModule.735550c.g.cs
+
+```csharp
+// <auto-generated/>
+
+#nullable enable
+#pragma warning disable
+
+using System;
+using System.Runtime.CompilerServices;
+using HotChocolate;
+using HotChocolate.Types;
+using HotChocolate.Execution.Configuration;
+
+namespace Microsoft.Extensions.DependencyInjection
+{
+    public static partial class TestsTypesRequestExecutorBuilderExtensions
+    {
+        public static IRequestExecutorBuilder AddTestsTypes(this IRequestExecutorBuilder builder)
+        {
+            builder.ConfigureDescriptorContext(ctx => ctx.TypeConfiguration.TryAdd(
+                "Tests::TestNamespace.Query",
+                global::HotChocolate.Types.OperationTypeNames.Query,
+                () => global::TestNamespace.Query.Initialize));
+            builder.ConfigureSchema(
+                b => b.TryAddRootType(
+                    () => new global::HotChocolate.Types.ObjectType(
+                        d => d.Name(global::HotChocolate.Types.OperationTypeNames.Query)),
+                    HotChocolate.Language.OperationType.Query));
+            return builder;
+        }
+    }
+}
+
+```
+
+## Query.WaAdMHmlGJHjtEI4nqY7WA.hc.g.cs
+
+```csharp
+// <auto-generated/>
+
+#nullable enable
+#pragma warning disable
+
+using System;
+using System.Runtime.CompilerServices;
+using HotChocolate;
+using HotChocolate.Types;
+using HotChocolate.Execution.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using HotChocolate.Internal;
+
+namespace TestNamespace
+{
+    internal static partial class Query
+    {
+        internal static void Initialize(global::HotChocolate.Types.IObjectTypeDescriptor descriptor)
+        {
+            var extension = descriptor.Extend();
+            var configuration = extension.Configuration;
+            var thisType = typeof(global::TestNamespace.Query);
+            var bindingResolver = extension.Context.ParameterBindingResolver;
+            var resolvers = new __Resolvers();
+
+            HotChocolate.Internal.ConfigurationHelper.ApplyConfiguration(
+                extension.Context,
+                descriptor,
+                null,
+                new global::HotChocolate.Types.QueryTypeAttribute());
+            configuration.ConfigurationsAreApplied = true;
+
+            var naming = descriptor.Extend().Context.Naming;
+
+            descriptor
+                .Field(naming.GetMemberName("Stuff", global::HotChocolate.Types.MemberKind.ObjectField))
+                .ExtendWith(static (field, context) =>
+                {
+                    var configuration = field.Configuration;
+                    var typeInspector = field.Context.TypeInspector;
+                    var bindingResolver = field.Context.ParameterBindingResolver;
+                    var naming = field.Context.Naming;
+
+                    configuration.Type = global::HotChocolate.Types.Descriptors.TypeReference.Create(
+                        typeInspector.GetTypeRef(typeof(global::System.Collections.Generic.KeyValuePair<int, string>), HotChocolate.Types.TypeContext.Output),
+                        new global::HotChocolate.Language.NonNullTypeNode(new global::HotChocolate.Language.ListTypeNode(new global::HotChocolate.Language.NonNullTypeNode(new global::HotChocolate.Language.NamedTypeNode("global__System_Collections_Generic_KeyValuePairOfintAndstring")))));
+                    configuration.ResultType = typeof(global::System.Collections.Generic.Dictionary<int, string?>);
+
+                    configuration.SetSourceGeneratorFlags();
+
+                    configuration.Resolvers = context.Resolvers.GetStuffAsync();
+                    configuration.ResultPostProcessor = global::HotChocolate.Execution.ListPostProcessor<global::System.Collections.Generic.KeyValuePair<int, string>>.Default;
+                },
+                (Resolvers: resolvers, ThisType: thisType));
+
+            Configure(descriptor);
+        }
+
+        static partial void Configure(global::HotChocolate.Types.IObjectTypeDescriptor descriptor);
+
+        private sealed class __Resolvers
+        {
+            public HotChocolate.Resolvers.FieldResolverDelegates GetStuffAsync()
+                => new global::HotChocolate.Resolvers.FieldResolverDelegates(resolver: GetStuffAsync);
+
+            private async global::System.Threading.Tasks.ValueTask<global::System.Object?> GetStuffAsync(global::HotChocolate.Resolvers.IResolverContext context)
+            {
+                var args0 = context.RequestAborted;
+                var result = await global::TestNamespace.Query.GetStuffAsync(args0);
+                return result;
+            }
+        }
+    }
+}
+
+
+```
+