Code review fixes, additional test

Author: oroztocil

src/Shared/RoslynUtils/SymbolExtensions.cs

@@ -67,6 +67,25 @@ public static bool HasAttribute(this ImmutableArray<AttributeData> attributes, I
         return attributes.TryGetAttribute(attributeType, out _);
     }
 
+    public static bool HasAttribute(this ITypeSymbol typeSymbol, INamedTypeSymbol attributeSymbol)
+    {
+        var current = typeSymbol;
+
+        while (current is not null)
+        {
+            if (current.GetAttributes().Any(attr =>
+                attr.AttributeClass is not null &&
+                SymbolEqualityComparer.Default.Equals(attr.AttributeClass, attributeSymbol)))
+            {
+                return true;
+            }
+
+            current = current.BaseType;
+        }
+
+        return false;
+    }
+
     public static bool TryGetAttribute(this ImmutableArray<AttributeData> attributes, INamedTypeSymbol attributeType, [NotNullWhen(true)] out AttributeData? matchedAttribute)
     {
         foreach (var attributeData in attributes)

src/Validation/gen/Extensions/ITypeSymbolExtensions.cs

@@ -175,21 +175,4 @@ internal static bool IsSkippedValidationParameter(this IParameterSymbol paramete
     {
         return parameter.HasAttribute(skipValidationAttributeSymbol) || parameter.Type.HasAttribute(skipValidationAttributeSymbol);
     }
-
-    internal static bool HasAttribute(this ITypeSymbol? typeSymbol, INamedTypeSymbol attributeSymbol)
-    {
-        while (typeSymbol is not null)
-        {
-            if (typeSymbol.GetAttributes().Any(attr =>
-                attr.AttributeClass is not null &&
-                SymbolEqualityComparer.Default.Equals(attr.AttributeClass, attributeSymbol)))
-            {
-                return true;
-            }
-
-            typeSymbol = typeSymbol.BaseType;
-        }
-
-        return false;
-    }
 }

src/Validation/src/SkipValidationAttribute.cs

@@ -10,7 +10,7 @@ namespace Microsoft.Extensions.Validation;
 /// When applied to a property, validation is skipped for that property.
 /// When applied to a parameter, validation is skipped for that parameter.
 /// When applied to a type, validation is skipped for all properties and parameters of that type.
-/// This includes skipping validation of nested propeeties for complex types.
+/// This includes skipping validation of nested properties for complex types.
 /// </summary>
 [Experimental("ASP0029", UrlFormat = "https://aka.ms/aspnet/analyzer/{0}")]
 [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = true)]

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

@@ -48,6 +48,11 @@ public class ComplexType
 
     public NestedType ObjectProperty { get; set; } = new NestedType();
 
+    [SkipValidation]
+    public List<NestedType> SkippedListOfNestedTypes { get; set; } = [];
+
+    public List<NestedType> ListOfNestedTypes { get; set; } = [];
+
     [SkipValidation]
     public NonSkippedBaseType SkippedBaseTypeProperty { get; set; } = new NonSkippedBaseType();
 
@@ -100,13 +105,32 @@ await VerifyValidatableType(compilation, "ComplexType", async (validationOptions
         {
             Assert.True(validationOptions.TryGetValidatableTypeInfo(type, out var validatableTypeInfo));
 
-            await InvalidNestedIntegerWithRangeProducesError(validatableTypeInfo);
-            await InvalidSkippedNestedIntegerWithRangeDoesNotProduceProduceError(validatableTypeInfo);
-            await InvalidSkippedIntegerWithRangeDoesNotProduceError(validatableTypeInfo);
-            await InvalidSubTypeNestedIntegersWithRangeProduceErrors(validatableTypeInfo);
-            await InvalidAlwaysSkippedTypeDoesNotProduceError(validatableTypeInfo);
+            await InvalidSkippedInteger_DoesNotProduceError(validatableTypeInfo);
+            await InvalidNestedInteger_ProducesError(validatableTypeInfo);
+            await InvalidSkippedNestedInteger_DoesNotProduceError(validatableTypeInfo);
+            await InvalidList_ProducesError(validatableTypeInfo);
+            await InvalidSkippedList_DoesNotProduceError(validatableTypeInfo);
+            await InvalidSubTypeNestedIntegers_ProduceErrors(validatableTypeInfo);
+            await InvalidAlwaysSkippedType_DoesNotProduceError(validatableTypeInfo);
 
-            async Task InvalidNestedIntegerWithRangeProducesError(IValidatableInfo validatableInfo)
+            async Task InvalidSkippedInteger_DoesNotProduceError(IValidatableInfo validatableInfo)
+            {
+                var instance = Activator.CreateInstance(type);
+                var intProperty = type.GetProperty("IntegerWithRange");
+                intProperty?.SetValue(instance, 5); // Set invalid value
+
+                var context = new ValidateContext
+                {
+                    ValidationOptions = validationOptions,
+                    ValidationContext = new ValidationContext(instance)
+                };
+
+                await validatableTypeInfo.ValidateAsync(instance, context, CancellationToken.None);
+
+                Assert.Null(context.ValidationErrors);
+            }
+
+            async Task InvalidNestedInteger_ProducesError(IValidatableInfo validatableInfo)
             {
                 var instance = Activator.CreateInstance(type);
                 var objectPropertyInstance = type.GetProperty("ObjectProperty").GetValue(instance);
@@ -128,7 +152,7 @@ async Task InvalidNestedIntegerWithRangeProducesError(IValidatableInfo validatab
                 });
             }
 
-            async Task InvalidSkippedNestedIntegerWithRangeDoesNotProduceProduceError(IValidatableInfo validatableInfo)
+            async Task InvalidSkippedNestedInteger_DoesNotProduceError(IValidatableInfo validatableInfo)
             {
                 var instance = Activator.CreateInstance(type);
                 var objectPropertyInstance = type.GetProperty("SkippedObjectProperty").GetValue(instance);
@@ -146,24 +170,59 @@ async Task InvalidSkippedNestedIntegerWithRangeDoesNotProduceProduceError(IValid
                 Assert.Null(context.ValidationErrors);
             }
 
-            async Task InvalidSkippedIntegerWithRangeDoesNotProduceError(IValidatableInfo validatableInfo)
+            async Task InvalidList_ProducesError(IValidatableInfo validatableInfo)
             {
-                var instance = Activator.CreateInstance(type);
-                var intProperty = type.GetProperty("IntegerWithRange");
-                intProperty?.SetValue(instance, 5); // Set invalid value
+                var rootInstance = Activator.CreateInstance(type);
+                var listInstance = Activator.CreateInstance(typeof(List<>).MakeGenericType(type.Assembly.GetType("NestedType")!));
+
+                // Create invalid item
+                var nestedTypeInstance = Activator.CreateInstance(type.Assembly.GetType("NestedType")!);
+                nestedTypeInstance.GetType().GetProperty("IntegerWithRange")?.SetValue(nestedTypeInstance, 5);
+
+                // Add to list
+                listInstance.GetType().GetMethod("Add")?.Invoke(listInstance, [nestedTypeInstance]);
 
+                type.GetProperty("ListOfNestedTypes")?.SetValue(rootInstance, listInstance);
                 var context = new ValidateContext
                 {
                     ValidationOptions = validationOptions,
-                    ValidationContext = new ValidationContext(instance)
+                    ValidationContext = new ValidationContext(rootInstance)
                 };
 
-                await validatableTypeInfo.ValidateAsync(instance, context, CancellationToken.None);
+                await validatableTypeInfo.ValidateAsync(rootInstance, context, CancellationToken.None);
+
+                Assert.Collection(context.ValidationErrors, kvp =>
+                {
+                    Assert.Equal("ListOfNestedTypes[0].IntegerWithRange", kvp.Key);
+                    Assert.Equal("The field IntegerWithRange must be between 10 and 100.", kvp.Value.Single());
+                });
+            }
+
+            async Task InvalidSkippedList_DoesNotProduceError(IValidatableInfo validatableInfo)
+            {
+                var rootInstance = Activator.CreateInstance(type);
+                var listInstance = Activator.CreateInstance(typeof(List<>).MakeGenericType(type.Assembly.GetType("NestedType")!));
+
+                // Create invalid item
+                var nestedTypeInstance = Activator.CreateInstance(type.Assembly.GetType("NestedType")!);
+                nestedTypeInstance.GetType().GetProperty("IntegerWithRange")?.SetValue(nestedTypeInstance, 5);
+
+                // Add to list
+                listInstance.GetType().GetMethod("Add")?.Invoke(listInstance, [nestedTypeInstance]);
+
+                type.GetProperty("SkippedListOfNestedTypes")?.SetValue(rootInstance, listInstance);
+                var context = new ValidateContext
+                {
+                    ValidationOptions = validationOptions,
+                    ValidationContext = new ValidationContext(rootInstance)
+                };
+
+                await validatableTypeInfo.ValidateAsync(rootInstance, context, CancellationToken.None);
 
                 Assert.Null(context.ValidationErrors);
             }
 
-            async Task InvalidSubTypeNestedIntegersWithRangeProduceErrors(IValidatableInfo validatableInfo)
+            async Task InvalidSubTypeNestedIntegers_ProduceErrors(IValidatableInfo validatableInfo)
             {
                 var instance = Activator.CreateInstance(type);
                 var objectPropertyInstance = type.GetProperty("NonSkippedSubTypeProperty").GetValue(instance);
@@ -194,7 +253,7 @@ async Task InvalidSubTypeNestedIntegersWithRangeProduceErrors(IValidatableInfo v
                     });
             }
 
-            async Task InvalidAlwaysSkippedTypeDoesNotProduceError(IValidatableInfo validatableInfo)
+            async Task InvalidAlwaysSkippedType_DoesNotProduceError(IValidatableInfo validatableInfo)
             {
                 var instance = Activator.CreateInstance(type);
                 var objectPropertyInstance = type.GetProperty("AlwaysSkippedProperty").GetValue(instance);

src/Validation/test/Microsoft.Extensions.Validation.GeneratorTests/snapshots/ValidationsGeneratorTests.DoesNotEmit_ForSkipValidationAttribute_OnClassProperties#ValidatableInfoResolver.g.verified.cs

@@ -118,6 +118,12 @@ public bool TryGetValidatableTypeInfo(global::System.Type type, [global::System.
                             name: "ObjectProperty",
                             displayName: "ObjectProperty"
                         ),
+                        new GeneratedValidatablePropertyInfo(
+                            containingType: typeof(global::ComplexType),
+                            propertyType: typeof(global::System.Collections.Generic.List<global::NestedType>),
+                            name: "ListOfNestedTypes",
+                            displayName: "ListOfNestedTypes"
+                        ),
                         new GeneratedValidatablePropertyInfo(
                             containingType: typeof(global::ComplexType),
                             propertyType: typeof(global::NonSkippedSubType),