Fix ValidationsGenerator ITypeParameterSymbol handling

src/Validation/gen/Parsers/ValidationsGenerator.TypesParser.cs

@@ -75,6 +75,25 @@ internal static bool TryExtractValidatableType(ITypeSymbol incomingTypeSymbol, W
             return false;
         }
 
+        // Type parameters (e.g., TRequest from a generic MapCommand<TRequest>() extension)
+        // have DeclaredAccessibility == NotApplicable. The concrete type is only known at
+        // call sites, not inside the generic method body where the endpoint delegate is
+        // defined. Walk constraint types to discover any validatable types reachable
+        // through type constraints.
+        if (typeSymbol is ITypeParameterSymbol typeParam)
+        {
+            // Add to visitedTypes BEFORE iterating constraints to prevent
+            // infinite recursion through circular constraints such as
+            // where T : class, IEnumerable<T>.
+            visitedTypes.Add(typeSymbol);
+            var foundValidatable = false;
+            foreach (var constraintType in typeParam.ConstraintTypes)
+            {
+                foundValidatable |= TryExtractValidatableType(constraintType, wellKnownTypes, validatableTypes, visitedTypes);
+            }
+            return foundValidatable;
+        }
+
         // Skip types that are not accessible from generated code
         if (typeSymbol.DeclaredAccessibility is not Accessibility.Public)
         {
@@ -209,6 +228,16 @@ private static ImmutableArray<ValidatableProperty> ExtractValidatableMembers(ITy
                             validatableTypes,
                             visitedTypes);
 
+                        // Skip properties whose type is a type parameter (e.g., TSelf
+                        // from CRTP pattern RequestBase<TSelf>). The emitter would
+                        // generate typeof(TSelf) which is not valid C#. Concrete
+                        // validatable types reachable through constraints are already
+                        // discovered by TryExtractValidatableType above.
+                        if (ContainsTypeParameter(correspondingProperty.Type))
+                        {
+                            continue;
+                        }
+
                         // Record primary-constructor parameters can carry [Display]/[DisplayName] too.
                         // Prefer the parameter's attribute over the property's.
                         var (paramLiteral, paramHasResource) = parameter.GetDisplayInfo(displayAttributeSymbol, displayNameAttributeSymbol);
@@ -276,6 +305,14 @@ private static ImmutableArray<ValidatableProperty> ExtractValidatableMembers(ITy
                 continue;
             }
 
+            // Skip properties whose type is a type parameter (e.g., TSelf
+            // from CRTP pattern RequestBase<TSelf>). The emitter would
+            // generate typeof(TSelf) which is not valid C#.
+            if (ContainsTypeParameter(member.Type))
+            {
+                continue;
+            }
+
             var (memberLiteral, memberHasResource) = member.GetDisplayInfo(displayAttributeSymbol, displayNameAttributeSymbol);
 
             members.Add(new ValidatableProperty(
@@ -310,4 +347,40 @@ internal static bool HasIValidatableObjectInterface(ITypeSymbol typeSymbol, Well
         var validatableObjectSymbol = wellKnownTypes.Get(WellKnownTypeData.WellKnownType.System_ComponentModel_DataAnnotations_IValidatableObject);
         return typeSymbol.ImplementsInterface(validatableObjectSymbol);
     }
+
+    /// <summary>
+    /// Returns true if the given type symbol contains an unresolved type parameter
+    /// anywhere in its type tree. This catches not only bare <c>T</c> but also
+    /// constructed types like <c>List&lt;T&gt;</c>, <c>T[]</c>, <c>T?</c>, and
+    /// <c>Dictionary&lt;string, T&gt;</c> — all of which would produce invalid
+    /// <c>typeof(...)</c> expressions in the emitted code.
+    /// </summary>
+    private static bool ContainsTypeParameter(ITypeSymbol type)
+    {
+        // Bare type parameter: T, TSelf, TSelf?
+        if (type is ITypeParameterSymbol)
+        {
+            return true;
+        }
+
+        // Array: T[], T[,], List<T>[]
+        if (type is IArrayTypeSymbol arrayType)
+        {
+            return ContainsTypeParameter(arrayType.ElementType);
+        }
+
+        // Constructed generic: List<T>, Dictionary<string, T>, Nullable<T>, Func<T, bool>
+        if (type is INamedTypeSymbol { IsGenericType: true } namedType)
+        {
+            foreach (var typeArg in namedType.TypeArguments)
+            {
+                if (ContainsTypeParameter(typeArg))
+                {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
 }