Emit validation info for types with only type-level attributes

Author: oroztocil

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

@@ -82,6 +82,11 @@ internal bool TryExtractValidatableType(ITypeSymbol incomingTypeSymbol, WellKnow
 
         visitedTypes.Add(typeSymbol);
 
+        var hasValidationAttributes = typeSymbol.GetAttributes()
+            .Any(attribute => attribute.AttributeClass != null &&
+                              attribute.AttributeClass.ImplementsValidationAttribute(
+                                  wellKnownTypes.Get(WellKnownTypeData.WellKnownType.System_ComponentModel_DataAnnotations_ValidationAttribute)));
+
         // Extract validatable types discovered in base types of this type and add them to the top-level list.
         var current = typeSymbol.BaseType;
         var hasValidatableBaseType = false;
@@ -107,7 +112,7 @@ internal bool TryExtractValidatableType(ITypeSymbol incomingTypeSymbol, WellKnow
         }
 
         // No validatable members or derived types found, so we don't need to add this type.
-        if (members.IsDefaultOrEmpty && !hasValidatableBaseType && !hasValidatableDerivedTypes)
+        if (members.IsDefaultOrEmpty && !hasValidationAttributes && !hasValidatableBaseType && !hasValidatableDerivedTypes)
         {
             return false;
         }

src/Validation/test/Microsoft.Extensions.Validation.GeneratorTests/ValidationsGenerator.ClassAttributes.cs

@@ -0,0 +1,170 @@
+#pragma warning disable ASP0029 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
+
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.ComponentModel.DataAnnotations;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Validation;
+
+namespace Microsoft.Extensions.Validation.GeneratorTests;
+
+public partial class ValidationsGeneratorTests : ValidationsGeneratorTestBase
+{
+    [Fact]
+    public async Task CanValidateValidationAttributesOnClasses()
+    {
+        var source = """
+#pragma warning disable ASP0029
+
+using System;
+using System.ComponentModel.DataAnnotations;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Validation;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.Extensions.DependencyInjection;
+
+var builder = WebApplication.CreateBuilder();
+
+builder.Services.AddValidation();
+
+var app = builder.Build();
+
+app.Run();
+
+[ValidatableType]
+[SumLimit]
+public class ComplexType : IPoint
+{
+    [Range(0, 15)]
+    public int X { get; set; } = 10;
+
+    [Range(0, 15)]
+    public int Y { get; set; } = 10;
+
+    public NestedType ObjectProperty { get; set; } = new NestedType();
+}
+
+// This class does not have any property-level validation attributes, but it has a class-level validation attribute.
+// Therefore, its type info should still be emitted in the generator output.
+[SumLimit]
+public class NestedType : IPoint
+{
+    public int X { get; set; } = 10;
+
+    public int Y { get; set; } = 10;
+}
+
+public interface IPoint
+{
+    int X { get; }
+    int Y { get; }
+}
+
+public class SumLimitAttribute : ValidationAttribute
+{
+    protected override ValidationResult? IsValid(object? value, ValidationContext validationContext)
+    {
+        if (value is IPoint point)
+        {
+            if (point.X + point.Y > 20)
+            {
+                return new ValidationResult($"Sum is too high");
+            }
+        }
+        return ValidationResult.Success;
+    }
+}
+""";
+        await Verify(source, out var compilation);
+        await VerifyValidatableType(compilation, "ComplexType", async (validationOptions, type) =>
+        {
+            Assert.True(validationOptions.TryGetValidatableTypeInfo(type, out var validatableTypeInfo));
+
+            await InvalidPropertyAttributeCheck_ProducesError_AndShortCirctuits(validatableTypeInfo);
+            await ValidClassAttributeCheck_DoesNotProduceError(validatableTypeInfo);
+            await InvalidClassAttributeCheck_ProducesError(validatableTypeInfo);
+            await InvalidNestedClassAttributeCheck_ProducesError_AndShortCircuits(validatableTypeInfo);
+
+            async Task InvalidPropertyAttributeCheck_ProducesError_AndShortCirctuits(IValidatableInfo validatableInfo)
+            {
+                var instance = Activator.CreateInstance(type);
+                type.GetProperty("X")?.SetValue(instance, 16);
+                type.GetProperty("Y")?.SetValue(instance, 0);
+
+                var context = new ValidateContext
+                {
+                    ValidationOptions = validationOptions,
+                    ValidationContext = new ValidationContext(instance)
+                };
+
+                await validatableTypeInfo.ValidateAsync(instance, context, CancellationToken.None);
+
+                Assert.NotNull(context.ValidationErrors);
+                var propertyAttributeError = Assert.Single(context.ValidationErrors);
+                Assert.Equal("X", propertyAttributeError.Key);
+                Assert.Equal("The field X must be between 0 and 15.", propertyAttributeError.Value.Single());
+            }
+
+            async Task ValidClassAttributeCheck_DoesNotProduceError(IValidatableInfo validatableInfo)
+            {
+                var instance = Activator.CreateInstance(type);
+
+                var context = new ValidateContext
+                {
+                    ValidationOptions = validationOptions,
+                    ValidationContext = new ValidationContext(instance)
+                };
+
+                await validatableTypeInfo.ValidateAsync(instance, context, CancellationToken.None);
+
+                Assert.Null(context.ValidationErrors);
+            }
+
+            async Task InvalidClassAttributeCheck_ProducesError(IValidatableInfo validatableInfo)
+            {
+                var instance = Activator.CreateInstance(type);
+                type.GetProperty("X")?.SetValue(instance, 11);
+                type.GetProperty("Y")?.SetValue(instance, 12);
+
+                var context = new ValidateContext
+                {
+                    ValidationOptions = validationOptions,
+                    ValidationContext = new ValidationContext(instance)
+                };
+
+                await validatableTypeInfo.ValidateAsync(instance, context, CancellationToken.None);
+
+                Assert.NotNull(context.ValidationErrors);
+                var classAttributeError = Assert.Single(context.ValidationErrors);
+                Assert.Equal(string.Empty, classAttributeError.Key);
+                Assert.Equal("Sum is too high", classAttributeError.Value.Single());
+            }
+
+            async Task InvalidNestedClassAttributeCheck_ProducesError_AndShortCircuits(IValidatableInfo validatableInfo)
+            {
+                var instance = Activator.CreateInstance(type);
+                var objectPropertyInstance = type.GetProperty("ObjectProperty").GetValue(instance);
+                objectPropertyInstance.GetType().GetProperty("X")?.SetValue(objectPropertyInstance, 11);
+                objectPropertyInstance.GetType().GetProperty("Y")?.SetValue(objectPropertyInstance, 12);
+
+                var context = new ValidateContext
+                {
+                    ValidationOptions = validationOptions,
+                    ValidationContext = new ValidationContext(instance)
+                };
+
+                await validatableTypeInfo.ValidateAsync(instance, context, CancellationToken.None);
+
+                Assert.NotNull(context.ValidationErrors);
+                var classAttributeError = Assert.Single(context.ValidationErrors);
+                Assert.Equal("ObjectProperty", classAttributeError.Key);
+                Assert.Equal("Sum is too high", classAttributeError.Value.Single());
+            }
+        });
+    }
+}