tmp

Author: javiercn

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

@@ -25,12 +25,12 @@ internal ImmutableArray<ValidatableType> TransformValidatableTypeWithAttribute(G
         var wellKnownTypes = WellKnownTypes.GetOrCreate(context.SemanticModel.Compilation);
         if (TryExtractValidatableType((ITypeSymbol)context.TargetSymbol, wellKnownTypes, ref validatableTypes, ref visitedTypes))
         {
-            return [..validatableTypes];
+            return [.. validatableTypes];
         }
         return [];
     }
 
-    internal static bool ShouldTransformSymbolWithValidatableTypeAttribute(SyntaxNode syntaxNode, CancellationToken _)
+    internal static bool ShouldTransformSymbolWithEmbeddedValidatableTypeAttribute(SyntaxNode syntaxNode, CancellationToken _)
     {
         // Only process class and record declarations
         if (syntaxNode is not (ClassDeclarationSyntax or RecordDeclarationSyntax))
@@ -54,7 +54,10 @@ internal static bool ShouldTransformSymbolWithValidatableTypeAttribute(SyntaxNod
         return false;
     }
 
-    internal ImmutableArray<ValidatableType> TransformValidatableTypeWithValidatableTypeAttribute(GeneratorSyntaxContext context, CancellationToken cancellationToken)
+    internal ImmutableArray<ValidatableType> TransformValidatableTypeWithEmbeddedValidatableTypeAttribute(
+        GeneratorSyntaxContext context,
+        GeneratorSettings settings,
+        CancellationToken cancellationToken)
     {
         if (context.Node is not (ClassDeclarationSyntax or RecordDeclarationSyntax))
         {
@@ -67,8 +70,9 @@ internal ImmutableArray<ValidatableType> TransformValidatableTypeWithValidatable
             return [];
         }
 
-        // Check if the type has a ValidatableTypeAttribute (framework or auto-generated)
-        if (!HasValidatableTypeAttribute(typeSymbol))
+        var validatableTypeAttributeName = $"{settings.RootNamespace}.ValidatableTypeAttribute";
+        // Check if the type has a ValidatableTypeAttribute (auto-generated)
+        if (!HasValidatableTypeAttribute(typeSymbol, validatableTypeAttributeName))
         {
             return [];
         }
@@ -79,7 +83,7 @@ internal ImmutableArray<ValidatableType> TransformValidatableTypeWithValidatable
 
         if (TryExtractValidatableType(typeSymbol, wellKnownTypes, ref validatableTypes, ref visitedTypes))
         {
-            return [..validatableTypes];
+            return [.. validatableTypes];
         }
         return [];
     }
@@ -92,7 +96,7 @@ private static bool IsValidatableTypeAttribute(AttributeSyntax attribute)
                name.EndsWith(".ValidatableTypeAttribute", StringComparison.Ordinal);
     }
 
-    private static bool HasValidatableTypeAttribute(ITypeSymbol typeSymbol)
+    private static bool HasValidatableTypeAttribute(ITypeSymbol typeSymbol, string validatableTypeAttributeName)
     {
         foreach (var attr in typeSymbol.GetAttributes())
         {
@@ -103,16 +107,15 @@ private static bool HasValidatableTypeAttribute(ITypeSymbol typeSymbol)
             }
 
             var name = attributeClass.Name;
-            var fullName = attributeClass.ToDisplayString();
-
-            // Check for framework attribute
-            if (fullName == "Microsoft.Extensions.Validation.ValidatableTypeAttribute")
+            var namespaceName = attributeClass.ContainingNamespace.ToDisplayString();
+            var fullName = $"{namespaceName}.{name}";
+            if (!string.Equals(fullName, validatableTypeAttributeName, StringComparison.Ordinal))
             {
-                return true;
+                continue;
             }
 
             // Check for auto-generated attribute (any namespace)
-            if (name == "ValidatableTypeAttribute")
+            if (name == validatableTypeAttributeName)
             {
                 // Additional check: ensure it's marked with [Embedded] to confirm it's auto-generated
                 foreach (var embeddedAttr in attributeClass.GetAttributes())

src/Validation/gen/ValidationsGenerator.cs

@@ -2,7 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Collections.Immutable;
 using System.Linq;
+using Microsoft.AspNetCore.App.Analyzers.Infrastructure;
 using Microsoft.CodeAnalysis;
 
 namespace Microsoft.Extensions.Validation;
@@ -33,23 +35,49 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
             predicate: FindAddValidation,
             transform: TransformAddValidation
         );
+
         // Extract types that have been marked with [ValidatableType].
         // This handles both the framework attribute and the auto-generated attribute.
-        var validatableTypesWithAttribute = context.SyntaxProvider.CreateSyntaxProvider(
-            predicate: ShouldTransformSymbolWithValidatableTypeAttribute,
-            transform: TransformValidatableTypeWithValidatableTypeAttribute
-        ).Where(types => types.Length > 0);
+        var validatableTypesWithAttribute = context.SyntaxProvider.ForAttributeWithMetadataName(
+            "Microsoft.Extensions.Validation.ValidatableTypeAttribute",
+            predicate: ShouldTransformSymbolWithAttribute,
+            transform: TransformValidatableTypeWithAttribute
+        );
+
+        // Extract types that have been marked with the embedded [ValidatableType].
+        var generatedValidatableTypesWithAttribute = context.SyntaxProvider.CreateSyntaxProvider(
+            predicate: ShouldTransformSymbolWithEmbeddedValidatableTypeAttribute,
+            transform: (context, cancellation) => context
+        ).Combine(generatorSettings)
+            .Select((combined, cancellation) =>
+            {
+                var (syntaxContext, settings) = combined;
+                if (!settings.ShouldGenerateAttribute || string.IsNullOrEmpty(settings.RootNamespace))
+                {
+                    return [];
+                }
+
+                return TransformValidatableTypeWithEmbeddedValidatableTypeAttribute(syntaxContext, settings, cancellation);
+            })
+            .Where(t => t.Length > 0);
+
+        var allValidatableTypes = generatedValidatableTypesWithAttribute.Collect()
+            .Combine(validatableTypesWithAttribute.Collect())
+            .SelectMany((pair, cancellation) => pair.Left.Concat(pair.Right).ToImmutableArray());
+
         // Extract all minimal API endpoints in the application.
         var endpoints = context.SyntaxProvider
             .CreateSyntaxProvider(
                 predicate: FindEndpoints,
                 transform: TransformEndpoints)
             .Where(endpoint => endpoint is not null);
+
         // Extract validatable types from all endpoints.
         var validatableTypesFromEndpoints = endpoints
             .Select(ExtractValidatableEndpoint);
+
         // Join all validatable types encountered in the type graph.
-        var validatableTypes = validatableTypesWithAttribute
+        var validatableTypes = allValidatableTypes
             .Concat(validatableTypesFromEndpoints)
             .Distinct(ValidatableTypeComparer.Instance)
             .Collect();
@@ -99,5 +127,5 @@ internal sealed class ValidatableTypeAttribute : global::System.Attribute
         context.AddSource("ValidatableTypeAttribute.g.cs", validatableTypeAttributeSource);
     }
 
-    private readonly record struct GeneratorSettings(string? RootNamespace, bool ShouldGenerateAttribute);
+    internal readonly record struct GeneratorSettings(string? RootNamespace, bool ShouldGenerateAttribute);
 }