Fix issue with runtime resolve on open generic class

src/EntityFrameworkCore.Projectables/Services/ProjectionExpressionResolver.cs

@@ -266,6 +266,21 @@ private static bool ParameterTypesMatch(
                 // For generic methods, use the generic definition so type parameters (TEntity, etc.)
                 // are used instead of the concrete closed-generic arguments.
                 var methodToInspect = method.IsGenericMethod ? method.GetGenericMethodDefinition() : method;
+
+                // When the containing type was converted to its generic type definition above,
+                // also obtain the method as it appears on that definition so that class-level
+                // generic type parameters (e.g. TTypeContactAddress) are used as parameter types
+                // instead of the concrete closed-generic type arguments (e.g. ConcreteAddressType).
+                // Without this, the generated class name computed here won't match the one produced
+                // by the source generator, causing resolution to silently fail.
+                if (declaringType.IsGenericTypeDefinition && methodToInspect.DeclaringType != declaringType)
+                {
+                    if (MethodBase.GetMethodFromHandle(methodToInspect.MethodHandle, declaringType.TypeHandle) is MethodInfo openMethod)
+                    {
+                        methodToInspect = openMethod;
+                    }
+                }
+
                 var parameters = methodToInspect.GetParameters();
 
                 if (parameters.Length > 0)
@@ -281,7 +296,18 @@ private static bool ParameterTypesMatch(
             {
                 // Constructors are stored under the synthetic name "_ctor".
                 memberLookupName = "_ctor";
-                var parameters = ctor.GetParameters();
+
+                // Get the constructor as seen from the generic type definition so parameter types use generic type parameters.
+                var ctorToInspect = ctor;
+                if (declaringType.IsGenericTypeDefinition && ctor.DeclaringType != declaringType)
+                {
+                    if (MethodBase.GetMethodFromHandle(ctor.MethodHandle, declaringType.TypeHandle) is ConstructorInfo openCtor)
+                    {
+                        ctorToInspect = openCtor;
+                    }
+                }
+
+                var parameters = ctorToInspect.GetParameters();
 
                 if (parameters.Length > 0)
                 {

tests/EntityFrameworkCore.Projectables.Generator.Tests/GenericTests.GenericClassMethodsWithTypeParameterParameter.verified.txt

@@ -0,0 +1,20 @@
+// <auto-generated/>
+#nullable disable
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using EntityFrameworkCore.Projectables;
+using Foo;
+
+namespace EntityFrameworkCore.Projectables.Generated
+{
+    [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+    static class Foo_Contact_GetDisplayNameByType_P0_TType<TType>
+        where TType : struct, global::System.Enum
+    {
+        static global::System.Linq.Expressions.Expression<global::System.Func<global::Foo.Contact<TType>, TType, string>> Expression()
+        {
+            return (global::Foo.Contact<TType> @this, TType type) => global::System.Linq.Enumerable.FirstOrDefault(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Where(@this.Addresses, a => a.Type.Equals(type)), a => a.Address.DisplayName));
+        }
+    }
+}

tests/EntityFrameworkCore.Projectables.Generator.Tests/GenericTests.cs

@@ -146,4 +146,47 @@ public Task GenericTypesWithConstraints()
 
         return Verifier.Verify(result.GeneratedTrees[0].ToString());
     }
+
+    /// <summary>
+    /// Regression test for the runtime resolver bug where methods in a generic class
+    /// with generic type-parameter parameters were not resolved.
+    /// The source generator part was always correct;
+    /// the failing side was the runtime resolver (fixed in ProjectionExpressionResolver).
+    /// </summary>
+    [Fact]
+    public Task GenericClassMethodsWithTypeParameterParameter()
+    {
+        var compilation = CreateCompilation(@"
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using EntityFrameworkCore.Projectables;
+
+namespace Foo {
+    public class Address {
+        public string DisplayName { get; set; }
+    }
+
+    public class ContactAddress<TType> where TType : struct, System.Enum {
+        public TType Type { get; set; }
+        public Address Address { get; set; }
+    }
+
+    public class Contact<TType> where TType : struct, System.Enum {
+        public IList<ContactAddress<TType>> Addresses { get; set; }
+
+        [Projectable]
+        public string GetDisplayNameByType(TType type) =>
+            Addresses.Where(a => a.Type.Equals(type)).Select(a => a.Address.DisplayName).FirstOrDefault();
+    }
+}
+");
+
+        var result = RunGenerator(compilation);
+
+        Assert.Empty(result.Diagnostics);
+        Assert.Single(result.GeneratedTrees);
+
+        return Verifier.Verify(result.GeneratedTrees[0].ToString());
+    }
 }

tests/EntityFrameworkCore.Projectables.Tests/Services/ProjectionExpressionResolverGenericTypeTests.cs

@@ -0,0 +1,192 @@
+using System.Linq.Expressions;
+using System.Reflection;
+using EntityFrameworkCore.Projectables.Services;
+
+// Hand-crafted generated classes that mimic what the source generator would emit for
+// Contact<T>.GetDisplayNameByType and GetDisplayNameWithComplementByType.
+// They live in this assembly so Assembly.GetType() can locate them during testing.
+//
+// Class names are computed by ProjectionExpressionClassNameGenerator.GenerateFullName:
+//   namespace  = "EntityFrameworkCore.Projectables.Tests.Services.GenericResolution"
+//   class path = ["Contact`1"]  →  "Contact" + arity suffix `1
+//   member     = <method name>
+//   param[0]   = "T"  (generic type parameter — correct after the fix)
+// Resulting CLR names end in _Contact_GetDisplayNameByType_P0_T`1 / ...WithComplement...
+namespace EntityFrameworkCore.Projectables.Generated
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using EntityFrameworkCore.Projectables.Tests.Services.GenericResolution;
+
+#pragma warning disable CA1812 // Avoid uninstantiated internal classes (accessed via reflection)
+
+    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+    static class EntityFrameworkCore_Projectables_Tests_Services_GenericResolution_Contact_GetDisplayNameByType_P0_T<T>
+        where T : struct, Enum
+    {
+#pragma warning disable IDE0051 // Private member unused (invoked via reflection)
+        static Expression<Func<Contact<T>, T, string?>> Expression()
+            => (@this, type) => @this.Addresses
+                .Where(a => a.Type.Equals(type))
+                .Select(a => a.Address.DisplayName)
+                .FirstOrDefault();
+#pragma warning restore IDE0051
+    }
+
+    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+    static class EntityFrameworkCore_Projectables_Tests_Services_GenericResolution_Contact_GetDisplayNameWithComplementByType_P0_T<T>
+        where T : struct, Enum
+    {
+#pragma warning disable IDE0051 // Private member unused (invoked via reflection)
+        static Expression<Func<Contact<T>, T, string?>> Expression()
+            => (@this, type) => @this.Addresses
+                .Where(a => a.Type.Equals(type))
+                .Select(a => a.Address.DisplayNameWithComplement)
+                .FirstOrDefault();
+#pragma warning restore IDE0051
+    }
+
+#pragma warning restore CA1812
+}
+
+namespace EntityFrameworkCore.Projectables.Tests.Services.GenericResolution
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using EntityFrameworkCore.Projectables;
+
+    // ── Test entities ─────────────────────────────────────────────────────────
+
+    public enum AddressKind { Home, Work }
+
+    public class AddressInfo
+    {
+        public string? DisplayName { get; init; }
+        public string? DisplayNameWithComplement { get; init; }
+    }
+
+    public class ContactAddress<T> where T : struct, Enum
+    {
+        public T Type { get; init; }
+        public AddressInfo Address { get; init; } = new();
+    }
+
+    /// <summary>
+    /// A generic class whose <c>[Projectable]</c> methods reproduce the reported runtime
+    /// resolution failure: when the resolver was called with a <see cref="MethodInfo"/> from a
+    /// <em>closed</em> generic type (e.g. <c>Contact&lt;AddressKind&gt;</c>), it read the
+    /// concrete parameter type (<c>AddressKind</c>) instead of the generic type parameter
+    /// (<c>T</c>), producing a wrong generated-class name and failing to find the expression.
+    /// </summary>
+    public class Contact<T> where T : struct, Enum
+    {
+        public IList<ContactAddress<T>> Addresses { get; init; } = new List<ContactAddress<T>>();
+
+        [Projectable]
+        public string? GetDisplayNameByType(T type) =>
+            Addresses.Where(a => a.Type.Equals(type)).Select(a => a.Address.DisplayName).FirstOrDefault();
+
+        [Projectable]
+        public string? GetDisplayNameWithComplementByType(T type) =>
+            Addresses.Where(a => a.Type.Equals(type)).Select(a => a.Address.DisplayNameWithComplement).FirstOrDefault();
+    }
+}
+
+namespace EntityFrameworkCore.Projectables.Tests.Services
+{
+    using System;
+    using System.Reflection;
+    using EntityFrameworkCore.Projectables.Tests.Services.GenericResolution;
+    using Xunit;
+
+    /// <summary>
+    /// Regression tests for the runtime resolution of <c>[Projectable]</c> methods
+    /// declared on a generic class when the <see cref="MethodInfo"/> is obtained from a
+    /// <em>closed</em> generic type instantiation.
+    /// </summary>
+    public class ProjectionExpressionResolverGenericTypeTests
+    {
+        // ── Helper ────────────────────────────────────────────────────────────
+
+        /// <summary>
+        /// Returns the <see cref="MethodInfo"/> for <paramref name="methodName"/> as it
+        /// appears on the <em>closed</em> generic type <c>Contact&lt;AddressKind&gt;</c>.
+        /// This is the same object that EF Core's expression tree captures when a lambda
+        /// such as <c>c => c.GetDisplayNameByType(kind)</c> is compiled.
+        /// </summary>
+        private static MethodInfo GetClosedMethod(string methodName)
+        {
+            var closedType = typeof(Contact<AddressKind>);
+            return closedType.GetMethod(methodName)
+                ?? throw new InvalidOperationException($"Method '{methodName}' not found on {closedType}.");
+        }
+
+        // ── Tests ─────────────────────────────────────────────────────────────
+
+        /// <summary>
+        /// Verifies that <c>GetDisplayNameByType</c> on the closed generic type
+        /// <c>Contact&lt;AddressKind&gt;</c> is resolved by the reflection-based path.
+        /// </summary>
+        [Fact]
+        public void GetDisplayNameByType_OnClosedGenericType_IsResolved()
+        {
+            var method = GetClosedMethod(nameof(Contact<AddressKind>.GetDisplayNameByType));
+
+            var result = ProjectionExpressionResolver.FindGeneratedExpressionViaReflection(method);
+
+            Assert.NotNull(result);
+        }
+
+        /// <summary>
+        /// Verifies that <c>GetDisplayNameWithComplementByType</c> on the closed generic type
+        /// <c>Contact&lt;AddressKind&gt;</c> is resolved by the reflection-based path.
+        /// This was the method specifically reported as "not resolved" in the original bug.
+        /// </summary>
+        [Fact]
+        public void GetDisplayNameWithComplementByType_OnClosedGenericType_IsResolved()
+        {
+            var method = GetClosedMethod(nameof(Contact<AddressKind>.GetDisplayNameWithComplementByType));
+
+            var result = ProjectionExpressionResolver.FindGeneratedExpressionViaReflection(method);
+
+            Assert.NotNull(result);
+        }
+
+        /// <summary>
+        /// Verifies that the resolved expression for <c>GetDisplayNameByType</c> has the
+        /// correct parameter types after closing the generic type with <c>AddressKind</c>.
+        /// </summary>
+        [Fact]
+        public void GetDisplayNameByType_ResolvedExpression_HasCorrectSignature()
+        {
+            var method = GetClosedMethod(nameof(Contact<AddressKind>.GetDisplayNameByType));
+
+            var expression = ProjectionExpressionResolver.FindGeneratedExpressionViaReflection(method);
+
+            Assert.NotNull(expression);
+            // Lambda must accept (Contact<AddressKind> @this, AddressKind type)
+            Assert.Equal(2, expression.Parameters.Count);
+            Assert.Equal(typeof(Contact<AddressKind>), expression.Parameters[0].Type);
+            Assert.Equal(typeof(AddressKind), expression.Parameters[1].Type);
+        }
+
+        /// <summary>
+        /// Verifies that the resolved expression for <c>GetDisplayNameWithComplementByType</c>
+        /// has the correct parameter types after closing the generic type with <c>AddressKind</c>.
+        /// </summary>
+        [Fact]
+        public void GetDisplayNameWithComplementByType_ResolvedExpression_HasCorrectSignature()
+        {
+            var method = GetClosedMethod(nameof(Contact<AddressKind>.GetDisplayNameWithComplementByType));
+
+            var expression = ProjectionExpressionResolver.FindGeneratedExpressionViaReflection(method);
+
+            Assert.NotNull(expression);
+            Assert.Equal(2, expression.Parameters.Count);
+            Assert.Equal(typeof(Contact<AddressKind>), expression.Parameters[0].Type);
+            Assert.Equal(typeof(AddressKind), expression.Parameters[1].Type);
+        }
+    }
+}