Merging main into darc-main-b3d99129-0da1-44dd-9167-5a0ff9ee9993

Author: dotnet-maestro[bot]

.github/policies/resourceManagement.yml

@@ -663,7 +663,7 @@ configuration:
       - isAction:
           action: Opened
       - isActivitySender:
-          user: app/dependabot
+          user: dependabot[bot]
           issueAuthor: False
       - targetsBranch:
           branch: main

src/Http/Http.Abstractions/src/Validation/ValidatableTypeInfo.cs

@@ -104,12 +104,20 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,
                 {
                     if (validationResult != ValidationResult.Success && validationResult.ErrorMessage is not null)
                     {
-                        var memberName = validationResult.MemberNames.First();
-                        var key = string.IsNullOrEmpty(originalPrefix) ?
-                            memberName :
-                            $"{originalPrefix}.{memberName}";
-
-                        context.AddOrExtendValidationError(key, validationResult.ErrorMessage);
+                        // Create a validation error for each member name that is provided
+                        foreach (var memberName in validationResult.MemberNames)
+                        {
+                            var key = string.IsNullOrEmpty(originalPrefix) ?
+                                memberName :
+                                $"{originalPrefix}.{memberName}";
+                            context.AddOrExtendValidationError(key, validationResult.ErrorMessage);
+                        }
+
+                        if (!validationResult.MemberNames.Any())
+                        {
+                            // If no member names are specified, then treat this as a top-level error
+                            context.AddOrExtendValidationError(string.Empty, validationResult.ErrorMessage);
+                        }
                     }
                 }
 

src/Http/Http.Abstractions/test/Validation/ValidatableTypeInfoTests.cs

@@ -495,6 +495,95 @@ public async Task Validate_RequiredOnPropertyShortCircuitsOtherValidations()
         Assert.Equal("The Password field is required.", error.Value.Single());
     }
 
+    [Fact]
+    public async Task Validate_IValidatableObject_WithZeroAndMultipleMemberNames_BehavesAsExpected()
+    {
+        var globalType = new TestValidatableTypeInfo(
+            typeof(GlobalErrorObject),
+            []); // no properties – nothing sets MemberName
+
+        var context = new ValidateContext
+        {
+            ValidationOptions = new TestValidationOptions(new Dictionary<Type, ValidatableTypeInfo>
+            {
+                { typeof(GlobalErrorObject), globalType }
+            })
+        };
+
+        var globalErrorInstance = new GlobalErrorObject { Data = -1 };
+        context.ValidationContext = new ValidationContext(globalErrorInstance);
+
+        await globalType.ValidateAsync(globalErrorInstance, context, default);
+
+        Assert.NotNull(context.ValidationErrors);
+        var globalError = Assert.Single(context.ValidationErrors);
+        Assert.Equal(string.Empty, globalError.Key);
+        Assert.Equal("Data must be positive.", globalError.Value.Single());
+
+        var multiType = new TestValidatableTypeInfo(
+            typeof(MultiMemberErrorObject),
+            [
+                CreatePropertyInfo(typeof(MultiMemberErrorObject), typeof(string), "FirstName", "FirstName", []),
+                CreatePropertyInfo(typeof(MultiMemberErrorObject), typeof(string), "LastName",  "LastName",  [])
+            ]);
+
+        context.ValidationErrors = [];
+        context.ValidationOptions = new TestValidationOptions(new Dictionary<Type, ValidatableTypeInfo>
+        {
+            { typeof(MultiMemberErrorObject), multiType }
+        });
+
+        var multiErrorInstance = new MultiMemberErrorObject { FirstName = "", LastName = "" };
+        context.ValidationContext = new ValidationContext(multiErrorInstance);
+
+        await multiType.ValidateAsync(multiErrorInstance, context, default);
+
+        Assert.NotNull(context.ValidationErrors);
+        Assert.Collection(context.ValidationErrors,
+            kvp =>
+            {
+                Assert.Equal("FirstName", kvp.Key);
+                Assert.Equal("FirstName and LastName are required.", kvp.Value.First());
+            },
+            kvp =>
+            {
+                Assert.Equal("LastName", kvp.Key);
+                Assert.Equal("FirstName and LastName are required.", kvp.Value.First());
+            });
+    }
+
+    // Returns no member names to validate https://github.com/dotnet/aspnetcore/issues/61739
+    private class GlobalErrorObject : IValidatableObject
+    {
+        public int Data { get; set; }
+
+        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            if (Data <= 0)
+            {
+                yield return new ValidationResult("Data must be positive.");
+            }
+        }
+    }
+
+    // Returns multiple member names to validate https://github.com/dotnet/aspnetcore/issues/61739
+    private class MultiMemberErrorObject : IValidatableObject
+    {
+        public string? FirstName { get; set; }
+        public string? LastName { get; set; }
+
+        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            if (string.IsNullOrEmpty(FirstName) || string.IsNullOrEmpty(LastName))
+            {
+                // MULTIPLE member names
+                yield return new ValidationResult(
+                    "FirstName and LastName are required.",
+                    [nameof(FirstName), nameof(LastName)]);
+            }
+        }
+    }
+
     private ValidatablePropertyInfo CreatePropertyInfo(
         Type containingType,
         Type propertyType,
@@ -534,7 +623,7 @@ public IEnumerable<ValidationResult> Validate(ValidationContext validationContex
         {
             if (Salary < 0)
             {
-                yield return new ValidationResult("Salary must be a positive value.", new[] { nameof(Salary) });
+                yield return new ValidationResult("Salary must be a positive value.", ["Salary"]);
             }
         }
     }

src/Http/Http.Extensions/gen/Microsoft.AspNetCore.Http.ValidationsGenerator/Extensions/ITypeSymbolExtensions.cs

@@ -46,8 +46,9 @@ public static ITypeSymbol UnwrapType(this ITypeSymbol type, INamedTypeSymbol enu
 
         if (type.NullableAnnotation == NullableAnnotation.Annotated)
         {
-            // Extract the underlying type from a reference type
-            type = type.OriginalDefinition;
+            // Remove the nullable annotation but keep any generic arguments, e.g. List<int>? → List<int>
+            // so we can retain them in future steps.
+            type = type.WithNullableAnnotation(NullableAnnotation.NotAnnotated);
         }
 
         if (type is INamedTypeSymbol namedType && namedType.IsEnumerable(enumerable) && namedType.TypeArguments.Length == 1)

src/Http/Http.Extensions/gen/Microsoft.AspNetCore.Http.ValidationsGenerator/Parsers/ValidationsGenerator.TypesParser.cs

@@ -29,13 +29,14 @@ internal ImmutableArray<ValidatableType> ExtractValidatableTypes(IInvocationOper
         List<ITypeSymbol> visitedTypes = [];
         foreach (var parameter in parameters)
         {
-            _ = TryExtractValidatableType(parameter.Type.UnwrapType(wellKnownTypes.Get(WellKnownTypeData.WellKnownType.System_Collections_IEnumerable)), wellKnownTypes, ref validatableTypes, ref visitedTypes);
+            _ = TryExtractValidatableType(parameter.Type, wellKnownTypes, ref validatableTypes, ref visitedTypes);
         }
         return [.. validatableTypes];
     }
 
-    internal bool TryExtractValidatableType(ITypeSymbol typeSymbol, WellKnownTypes wellKnownTypes, ref HashSet<ValidatableType> validatableTypes, ref List<ITypeSymbol> visitedTypes)
+    internal bool TryExtractValidatableType(ITypeSymbol incomingTypeSymbol, WellKnownTypes wellKnownTypes, ref HashSet<ValidatableType> validatableTypes, ref List<ITypeSymbol> visitedTypes)
     {
+        var typeSymbol = incomingTypeSymbol.UnwrapType(wellKnownTypes.Get(WellKnownTypeData.WellKnownType.System_Collections_IEnumerable));
         if (typeSymbol.SpecialType != SpecialType.None)
         {
             return false;
@@ -126,7 +127,7 @@ internal ImmutableArray<ValidatableProperty> ExtractValidatableMembers(ITypeSymb
                         // Check if the property's type is validatable, this resolves
                         // validatable types in the inheritance hierarchy
                         var hasValidatableType = TryExtractValidatableType(
-                            correspondingProperty.Type.UnwrapType(wellKnownTypes.Get(WellKnownTypeData.WellKnownType.System_Collections_IEnumerable)),
+                            correspondingProperty.Type,
                             wellKnownTypes,
                             ref validatableTypes,
                             ref visitedTypes);
@@ -153,7 +154,7 @@ internal ImmutableArray<ValidatableProperty> ExtractValidatableMembers(ITypeSymb
                 continue;
             }
 
-            var hasValidatableType = TryExtractValidatableType(member.Type.UnwrapType(wellKnownTypes.Get(WellKnownTypeData.WellKnownType.System_Collections_IEnumerable)), wellKnownTypes, ref validatableTypes, ref visitedTypes);
+            var hasValidatableType = TryExtractValidatableType(member.Type, wellKnownTypes, ref validatableTypes, ref visitedTypes);
             var attributes = ExtractValidationAttributes(member, wellKnownTypes, out var isRequired);
 
             // If the member has no validation attributes or validatable types and is not required, skip it.

src/Http/Http.Extensions/test/ValidationsGenerator/ValidationsGenerator.ComplexType.cs

@@ -45,7 +45,8 @@ public class ComplexType
 
     public SubTypeWithInheritance PropertyWithInheritance { get; set; } = new SubTypeWithInheritance("some-value", default);
 
-    public List<SubType> ListOfSubTypes { get; set; } = [];
+    // Nullable to validate https://github.com/dotnet/aspnetcore/issues/61737
+    public List<SubType>? ListOfSubTypes { get; set; } = [];
 
     [DerivedValidation(ErrorMessage = "Value must be an even number")]
     public int IntegerWithDerivedValidationAttribute { get; set; }

src/Http/Http.Extensions/test/ValidationsGenerator/ValidationsGenerator.Parsable.cs

@@ -39,7 +39,7 @@ public class ComplexTypeWithParsableProperties
     public TimeOnly? TimeOnlyWithRequiredValue { get; set; } = TimeOnly.FromDateTime(DateTime.UtcNow);
 
     [Url(ErrorMessage = "The field Url must be a valid URL.")]
-    public Uri? Url { get; set; } = new Uri("https://example.com");
+    public string? Url { get; set; } = "https://example.com";
 
     [Required]
     [Range(typeof(DateOnly), "2023-01-01", "2025-12-31", ErrorMessage = "Date must be between 2023-01-01 and 2025-12-31")]

src/Http/Http.Extensions/test/ValidationsGenerator/snapshots/ValidationsGeneratorTests.CanValidateTypeWithParsableProperties#ValidatableInfoResolver.g.verified.cs

@@ -95,7 +95,7 @@ private ValidatableTypeInfo CreateComplexTypeWithParsableProperties()
                     ),
                     new GeneratedValidatablePropertyInfo(
                         containingType: typeof(global::ComplexTypeWithParsableProperties),
-                        propertyType: typeof(global::System.Uri),
+                        propertyType: typeof(string),
                         name: "Url",
                         displayName: "Url"
                     ),