Gate record primary-constructor members in the validations generator

The record primary-constructor path in ExtractValidatableMembers added
members unconditionally, unlike the property path which skips members that
have no validation attributes and whose type is not itself validatable. As
a result any record with a primary constructor was emitted as a validatable
type, which also made every property of that record type a validatable
member of its containing types.

This inflated generated code, added per-request traversal for members that
can never produce an error, consumed the MaxDepth budget for nested record
graphs, and made records behave differently from equivalently-shaped classes.

Apply the same gate to the record path, capturing the previously-discarded
TryExtractValidatableType result and checking the parameter as well as the
corresponding property. Attributes on record primary-constructor parameters
bind to the parameter rather than the property by default, so both are
checked, matching how the runtime already resolves them.

Fixes #68805

Author: Arul1998

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

@@ -243,12 +243,25 @@ private static ImmutableArray<ValidatableProperty> ExtractValidatableMembers(ITy
 
                         // Check if the property's type is validatable, this resolves
                         // validatable types in the inheritance hierarchy
-                        _ = TryExtractValidatableType(
+                        var hasValidatableType = TryExtractValidatableType(
                             correspondingProperty.Type,
                             wellKnownTypes,
                             validatableTypes,
                             visitedTypes);
 
+                        // If neither the parameter nor the corresponding property has validation
+                        // attributes, and the property's type is not itself validatable, skip it.
+                        // This mirrors the gate applied to non-record properties below and prevents
+                        // records with no validatable members from being emitted as validatable types.
+                        // Attributes on record primary constructor parameters bind to the parameter
+                        // rather than the property by default, so both are checked.
+                        if (!HasValidationAttributes(parameter, wellKnownTypes)
+                            && !HasValidationAttributes(correspondingProperty, wellKnownTypes)
+                            && !hasValidatableType)
+                        {
+                            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);

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

@@ -526,4 +526,88 @@ async Task ValidInputProducesNoWarnings(Endpoint endpoint)
         });
 
     }
+
+    [Fact]
+    public Task DoesNotEmit_ForRecordWithNoValidatableMembers()
+    {
+        // A record whose primary-constructor parameters carry no validation attributes and
+        // whose types are not themselves validatable should not be emitted as a validatable
+        // type - matching the behavior of an equivalently-shaped class. A record with a
+        // validation attribute on a primary-constructor parameter must still be emitted.
+        var source = """
+using System.ComponentModel.DataAnnotations;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.Validation;
+using Microsoft.Extensions.DependencyInjection;
+
+static class Program
+{
+    public static void Main(string[] args)
+    {
+        var builder = WebApplication.CreateBuilder();
+        builder.Services.AddValidation();
+        var app = builder.Build();
+        app.Run();
+    }
+}
+
+[ValidatableType]
+public class Holder
+{
+    [Required]
+    public string Name { get; set; } = "";
+    public PlainRecord? PlainRec { get; set; }
+    public PlainClass? PlainCls { get; set; }
+    public MixedRecord? Mixed { get; set; }
+    public ValidatedRecord? ValidatedRec { get; set; }
+}
+
+// No validation attributes and no validatable member types -> should not be emitted.
+public record PlainRecord(int Number, string Text);
+
+// Same shape as PlainRecord but a class -> already correctly not emitted; asserted for symmetry.
+public class PlainClass
+{
+    public int Number { get; set; }
+    public string Text { get; set; } = "";
+}
+
+// Neither the primary-constructor parameters nor the body properties are validatable
+// -> the record must not be emitted (documents the case called out in #68805).
+public record MixedRecord(int CtorParam, string CtorText)
+{
+    public int BodyProperty { get; set; }
+    public string BodyText { get; set; } = "";
+}
+
+// [Required] binds to the primary-constructor parameter -> must still be emitted.
+public record ValidatedRecord([Required] string Name, int Age);
+""";
+        RunGenerator(source, out var compilation);
+        return VerifyValidatableType(compilation, "Holder", (validationOptions, type) =>
+        {
+            // The containing type is validatable (it has a [Required] member).
+            Assert.True(validationOptions.TryGetValidatableTypeInfo(type, out var holderInfo));
+
+            // Core repro from #68805: a record with no validatable members must NOT become a
+            // validatable member of its containing type - matching the equivalently-shaped class.
+            // Before the fix, PlainRec (but not PlainCls) was incorrectly a validatable member.
+            Assert.True(holderInfo.TryFindProperty("Name", validationOptions, out _));
+            Assert.False(holderInfo.TryFindProperty("PlainRec", validationOptions, out _));
+            Assert.False(holderInfo.TryFindProperty("PlainCls", validationOptions, out _));
+            Assert.False(holderInfo.TryFindProperty("Mixed", validationOptions, out _));
+            Assert.True(holderInfo.TryFindProperty("ValidatedRec", validationOptions, out _));
+
+            // The unvalidatable records are also not emitted as standalone validatable types.
+            Assert.False(validationOptions.TryGetValidatableTypeInfo(type.Assembly.GetType("PlainRecord")!, out _));
+            Assert.False(validationOptions.TryGetValidatableTypeInfo(type.Assembly.GetType("PlainClass")!, out _));
+            Assert.False(validationOptions.TryGetValidatableTypeInfo(type.Assembly.GetType("MixedRecord")!, out _));
+
+            // Regression guard: a record with a validation attribute on a primary-constructor
+            // parameter is still emitted (the parameter, not the property, carries the attribute).
+            Assert.True(validationOptions.TryGetValidatableTypeInfo(type.Assembly.GetType("ValidatedRecord")!, out _));
+
+            return Task.CompletedTask;
+        });
+    }
 }

src/Validation/test/Microsoft.Extensions.Validation.GeneratorTests/ValidationsGeneratorTestBase.cs

@@ -64,6 +64,28 @@ internal static Task Verify(string source, out Compilation compilation)
             .DisableRequireUniquePrefix();
     }
 
+    // Runs the generator against the source and returns the resulting compilation without
+    // producing a Verify snapshot. Useful for tests that assert the generated behavior at
+    // runtime (via VerifyValidatableType/VerifyEndpoint) rather than the generated source text.
+    internal static void RunGenerator(string source, out Compilation compilation)
+    {
+        var references = GetMetadataReferences();
+        var inputCompilation = CSharpCompilation.Create("ValidationsGeneratorSample",
+            [CSharpSyntaxTree.ParseText(source, options: ParseOptions, path: "Program.cs")],
+            references,
+            new CSharpCompilationOptions(OutputKind.ConsoleApplication));
+
+        var programEmitResult = inputCompilation.Emit(Stream.Null);
+        if (!programEmitResult.Success)
+        {
+            throw new InvalidOperationException($"Failed to compile Program.cs: {string.Join(Environment.NewLine, programEmitResult.Diagnostics)}");
+        }
+
+        var generator = new ValidationsGenerator();
+        var driver = CSharpGeneratorDriver.Create(generators: [generator.AsSourceGenerator()], parseOptions: ParseOptions);
+        driver.RunGeneratorsAndUpdateCompilation(inputCompilation, out compilation, out _);
+    }
+
     private static IEnumerable<MetadataReference> GetMetadataReferences()
         => AppDomain.CurrentDomain.GetAssemblies()
             .Where(assembly => !assembly.IsDynamic && !string.IsNullOrWhiteSpace(assembly.Location))