Add AutoDetails feature for generating detail classes

Updated Directory.Build.props to upgrade ExtSrcGenVer to 0.1.10. Introduced AutoDetailsGenerator for creating detail classes from properties with AutoDetailsAttribute. Enhanced AutoDetailsInformation with constructors, equality, and hashing methods. Modified AutoPropertiesGenerator to include AutoDetailsAssignDescriptorResolver and refactored property handling logic. Added AutoDetailsAssignDescriptorResolver class. Updated AutoPropertyOriginPropertiesRetriever for efficiency. Extended AutoPropertiesInformation to handle autoDetails. Updated AutoSelectInformation for direct generation. Added AutoDetailsTests1 to verify new feature functionality.

Author: eglauko

src/Directory.Build.props

@@ -6,7 +6,7 @@
 	</PropertyGroup>
 	<PropertyGroup>
 		<DotNetCoreVersion>8.0.20</DotNetCoreVersion>
-		<ExtSrcGenVer>0.1.8</ExtSrcGenVer>
+		<ExtSrcGenVer>0.1.10</ExtSrcGenVer>
 	</PropertyGroup>
 	<PropertyGroup>
 		<Ver>0.2.0</Ver>

src/RoyalCode.SmartSelector.Generators/Generators/AutoDetailsGenerator.cs

@@ -1,9 +1,117 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
+using Microsoft.CodeAnalysis;
 
 namespace RoyalCode.SmartSelector.Generators.Generators;
 
-internal class AutoDetailsGenerator
+internal static class AutoDetailsGenerator
 {
+    private const string AutoDetailsAttributeName = "AutoDetailsAttribute";
+
+    internal static bool TryCreate(
+        PropertyDescriptor property,
+        TypeDescriptor fromType,
+        out AutoDetailsInformation? autoDetailInfo)
+    {
+        autoDetailInfo = null;
+
+        // verify if the property has AutoDetails attribute
+        var autoDetailsAttribute = property.Symbol?.GetAttributes().FirstOrDefault(attr =>
+        {
+            var attrName = attr.AttributeClass?.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
+            return attrName == AutoDetailsAttributeName;
+        });
+
+        if (autoDetailsAttribute is null)
+            return false;
+
+        // get the property of the fromType that matches the property name
+        var fromProperty = fromType.CreateProperties(p => p.Name == property.Name && p.GetMethod is not null).FirstOrDefault();
+
+        // if not found, return error diagnostic
+        if (fromProperty is null)
+        {
+            autoDetailInfo = new AutoDetailsInformation(
+                Diagnostic.Create(AnalyzerDiagnostics.PropertyNotMatch, null, property.Name));
+            return true;
+        }
+
+        // get type descriptors
+        var propertyType = property.Type;
+        var fromPropertyType = fromProperty.Type;
+
+        // create auto properties information
+        var autoPropertiesInfo = AutoPropertiesGenerator.CreateInformation(propertyType, fromPropertyType, autoDetailsAttribute);
+
+        // try update the namespace for the generated type with same namespaces of the property declaring type.
+        var propertyNamespace = property.Symbol?.ContainingNamespace?.ToDisplayString();
+        if (propertyNamespace is not null)
+            propertyType.Namespaces[0] = propertyNamespace;
+
+        // set the defined properties for the auto detail info
+        propertyType.DefinedProperties = autoPropertiesInfo.Properties;
+
+        // create the auto detail info
+        autoDetailInfo = new AutoDetailsInformation(
+            $"{fromPropertyType.Name}Details",
+            autoPropertiesInfo);
+
+        return true;
+    }
+
+    internal static void Generate(
+        SourceProductionContext context,
+        string className, 
+        AutoPropertiesInformation autoPropertiesInformation)
+    {
+        // Gera uma nova classe DTO contendo as propriedades de autoPropertiesInformation.
+        // Segue o mesmo estilo de geração usado por AutoPropertiesGenerator.Generate.
+
+        var originType = autoPropertiesInformation.OriginType;
+        var properties = autoPropertiesInformation.Properties;
+
+        // Se não há propriedades, não gera nada.
+        if (originType == null || properties.Length == 0)
+            return;
+
+        // 1 - Criação da classe
+        var detailsClass = new ClassGenerator(className, originType.Namespaces[0]);
+        
+
+        // 1.1 - Modificadores (usa a mesma acessibilidade do tipo de origem)
+        if (originType.Symbol?.DeclaredAccessibility == Accessibility.Public)
+        {
+            detailsClass.Modifiers.Public();
+        }
+        else if (originType.Symbol?.DeclaredAccessibility == Accessibility.Internal)
+        {
+            detailsClass.Modifiers.Internal();
+        }
+        else if (originType.Symbol?.DeclaredAccessibility == Accessibility.Protected)
+        {
+            detailsClass.Modifiers.Protected();
+        }
+        else if (originType.Symbol?.DeclaredAccessibility == Accessibility.Private)
+        {
+            detailsClass.Modifiers.Private();
+        }
+
+        // 1.2 - partial, para o desenvolvedor poder estender
+        detailsClass.Modifiers.Public();
+
+        // 2 - Criação das propriedades públicas com get/set
+        foreach (var p in properties)
+        {
+            var propertyType = p.Type.HasNamedTypeSymbol(out var typeSymbol)
+                ? TypeDescriptor.Create(typeSymbol)
+                : p.Type;
+
+            var prop = new PropertyGenerator(propertyType, p.Name);
+            prop.Modifiers.Public();
+
+            detailsClass.Properties.Add(prop);
+        }
+
+        // 3 - Configura o nome do arquivo e gera
+        detailsClass.FileName = $"{className}.AutoDetails.g.cs";
+        detailsClass.Generate(context);
+    }
 }

src/RoyalCode.SmartSelector.Generators/Generators/AutoDetailsInformation.cs

@@ -9,8 +9,61 @@ internal class AutoDetailsInformation : IEquatable<AutoDetailsInformation>
     private readonly string? detailsClassName;
     private readonly AutoPropertiesInformation? autoPropertiesInformation;
 
+    public AutoDetailsInformation(Diagnostic diagnostic)
+    {
+        diagnostics = [diagnostic];
+    }
+
+    public AutoDetailsInformation(
+        string detailsClassName,
+        AutoPropertiesInformation autoPropertiesInformation)
+    {
+        this.detailsClassName = detailsClassName;
+        this.autoPropertiesInformation = autoPropertiesInformation;
+    }
+
     public bool Equals(AutoDetailsInformation other)
     {
-        throw new NotImplementedException();
+        if (other == null)
+        {
+            return false;
+        }
+        if (ReferenceEquals(this, other))
+        {
+            return true;
+        }
+        return diagnostics?.SequenceEqual(other.diagnostics) == true &&
+               detailsClassName == other.detailsClassName &&
+               Equals(autoPropertiesInformation, other.autoPropertiesInformation);
+    }
+
+    public override bool Equals(object obj)
+    {
+        return obj is AutoDetailsInformation other && Equals(other);
+    }
+
+    public override int GetHashCode()
+    {
+        var hashCode = 2147442367;
+        hashCode = (hashCode * -1521134295) + (diagnostics != null ? diagnostics.GetHashCode() : 0);
+        hashCode = (hashCode * -1521134295) + (detailsClassName != null ? detailsClassName.GetHashCode() : 0);
+        hashCode = (hashCode * -1521134295) + (autoPropertiesInformation != null ? autoPropertiesInformation.GetHashCode() : 0);
+        return hashCode;
+    }
+
+    internal void Generate(SourceProductionContext context)
+    {
+        if (diagnostics is not null)
+        {
+            foreach (var diagnostic in diagnostics)
+            {
+                context.ReportDiagnostic(diagnostic);
+            }
+        }
+
+        if (autoPropertiesInformation is not null)
+        {
+            AutoDetailsGenerator.Generate(context, detailsClassName!, autoPropertiesInformation!);
+        }
     }
 }

src/RoyalCode.SmartSelector.Generators/Generators/AutoPropertiesGenerator.cs

@@ -1,7 +1,6 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using System.Text;
 
 namespace RoyalCode.SmartSelector.Generators.Generators;
 
@@ -15,6 +14,7 @@ internal static class AutoPropertiesGenerator
     internal static MatchOptions MatchOptions { get; } = new()
     {
         OriginPropertiesRetriever = new AutoPropertyOriginPropertiesRetriever(),
+        AdditionalAssignDescriptorResolvers = [new AutoDetailsAssignDescriptorResolver()],
     };
 
     internal static bool Predicate(SyntaxNode node, CancellationToken token)
@@ -135,25 +135,37 @@ internal static AutoPropertiesInformation CreateInformation(
         TypeDescriptor modelType,
         ITypeSymbol fromType,
         AttributeData autoPropertyAttribute)
+    {
+        // gera o TypeDescriptor do fromType
+        var fromTypeDescriptor = TypeDescriptor.Create(fromType);
+
+        return CreateInformation(modelType, fromTypeDescriptor, autoPropertyAttribute);
+    }
+
+    internal static AutoPropertiesInformation CreateInformation(
+        TypeDescriptor modelType,
+        TypeDescriptor fromType,
+        AttributeData autoPropertyAttribute)
     {
         var excluded = new HashSet<string>(StringComparer.Ordinal);
         var flattening = new HashSet<string>(StringComparer.Ordinal);
 
         // obtém Exclude de NamedArguments
         foreach (var namedArg in autoPropertyAttribute.NamedArguments)
             if (namedArg.Key == "Exclude" && namedArg.Value.Kind == TypedConstantKind.Array && namedArg.Value.Values != null)
+            {
                 foreach (var v in namedArg.Value.Values)
                     if (v.Value is string s)
                         excluded.Add(s);
+            }
             else if (namedArg.Key == "Flattening" && namedArg.Value.Kind == TypedConstantKind.Array && namedArg.Value.Values != null)
-                        foreach (var fv in namedArg.Value.Values)
-                            if (fv.Value is string fs)
-                                flattening.Add(fs);
-
-        // gera o TypeDescriptor do fromType
-        var fromTypeDescriptor = TypeDescriptor.Create(fromType);
+            {
+                foreach (var fv in namedArg.Value.Values)
+                    if (fv.Value is string fs)
+                        flattening.Add(fs);
+            }
 
-        return CreateInformation(modelType, fromTypeDescriptor, excluded, flattening);
+        return CreateInformation(modelType, fromType, excluded, flattening);
     }
 
     internal static AutoPropertiesInformation CreateInformation(
@@ -162,10 +174,19 @@ internal static AutoPropertiesInformation CreateInformation(
         HashSet<string> excluded,
         HashSet<string>? flattening)
     {
+        var autoDetails = new List<AutoDetailsInformation>();
+
         // declared properties in model type are always excluded
         foreach (var p in modelType.CreateProperties(p => p.SetMethod is not null))
+        {
             excluded.Add(p.Name);
 
+            // processa se propriedade se tem atributo AutoDetails
+            if(AutoDetailsGenerator.TryCreate(p, fromType, out var autoDetailInfo))
+            {
+                autoDetails.Add(autoDetailInfo!);
+            }
+        }
         var sourceProps = fromType.CreateProperties(p => p.GetMethod is not null);
 
         // filtra propriedades do source,
@@ -192,7 +213,7 @@ internal static AutoPropertiesInformation CreateInformation(
             generated.Add(new PropertyDescriptor(p.Type, p.Name, p.Symbol));
         }
 
-        return new AutoPropertiesInformation(modelType, [.. generated]);
+        return new AutoPropertiesInformation(modelType, [.. generated], [.. autoDetails]);
     }
 
     private static IReadOnlyList<PropertyDescriptor> CreateFlattening(
@@ -339,8 +360,6 @@ internal static void Generate(AutoPropertiesInformation propertiesInfo, SourcePr
         partialClass.FileName = $"{origin.Name}.AutoProperties.g.cs";
         partialClass.Generate(context);
     }
-
-
 }
 
 internal class AutoPropertyOriginPropertiesRetriever : IOriginPropertiesRetriever
@@ -351,9 +370,12 @@ internal class AutoPropertyOriginPropertiesRetriever : IOriginPropertiesRetrieve
 
     public IReadOnlyList<PropertyDescriptor> GetProperties(TypeDescriptor origin)
     {
+        var originProperties = MatchOptions.GetOriginProperties(origin);
+        origin.DefinedProperties = originProperties;
         var typeSymbol = origin.Symbol;
+
         if (typeSymbol == null)
-            return MatchOptions.GetOriginProperties(origin);
+            return originProperties;
 
         // Verifica se no type existe:
         // - o AutoPropertiesAttribute com AutoSelectAttribute<TFrom>
@@ -378,18 +400,18 @@ public IReadOnlyList<PropertyDescriptor> GetProperties(TypeDescriptor origin)
 
             // se não tiver, retorna o padrão
             if (autoSelectAttribute == null)
-                return MatchOptions.GetOriginProperties(origin);
+                return originProperties;
 
             // obtém o tipo TFrom
             var fromType = autoSelectAttribute.AttributeClass?.TypeArguments.FirstOrDefault();
             if (fromType == null)
-                return MatchOptions.GetOriginProperties(origin);
+                return originProperties;
 
             // cria a informação
             var info = AutoPropertiesGenerator.CreateInformation(origin, fromType, autoSelectAttribute);
 
             // pega as propriedades da origem mais as da informação
-            return [.. MatchOptions.GetOriginProperties(origin), .. info.Properties];
+            return [.. originProperties, .. info.Properties];
         }
 
         // obtém o AutoPropertiesAttribute<TFrom>
@@ -404,15 +426,64 @@ public IReadOnlyList<PropertyDescriptor> GetProperties(TypeDescriptor origin)
             // obtém o tipo TFrom
             var fromType = autoPropertiesAttribute.AttributeClass?.TypeArguments.FirstOrDefault();
             if (fromType == null)
-                return MatchOptions.GetOriginProperties(origin);
+                return originProperties;
 
             // cria a informação
             var info = AutoPropertiesGenerator.CreateInformation(origin, fromType, autoPropertiesAttribute);
 
             // pega as propriedades da origem mais as da informação
-            return [.. MatchOptions.GetOriginProperties(origin), .. info.Properties];
+            return [.. originProperties, .. info.Properties];
         }
 
-        return MatchOptions.GetOriginProperties(origin);
+        return originProperties;
     }
 }
+
+internal class AutoDetailsAssignDescriptorResolver : IAssignDescriptorResolver
+{
+    public bool TryCreateAssignDescriptor(
+        TypeDescriptor leftType,
+        TypeDescriptor rightType,
+        SemanticModel model,
+        MatchOptions options,
+        out AssignDescriptor? descriptor)
+    {
+        descriptor = null;
+
+        // check if the left type has defined properties
+        if (!leftType.HasDefinedProperties())
+            return false;
+
+        // obtém propriedades do tipo de origem
+        var leftProperties = options.OriginPropertiesRetriever.GetProperties(leftType);
+
+        // valida se tem propriedades
+        if (leftProperties.Count == 0)
+            return false;
+
+        // obtém propriedades do tipo de destino
+        var rightProperties = options.TargetPropertiesRetriever.GetProperties(rightType);
+
+        // valida se tem propriedades
+        if (rightProperties.Count == 0)
+            return false;
+
+        // faz o match entre as propriedades
+        // match das propriedades da classe com o attributo e a classe definida no TFrom.
+        var matchSelection = MatchSelection.Create(leftType, leftProperties, rightType, rightProperties, model, options);
+
+        // se tem problemas, não é possível fazer o match.
+        if (matchSelection.HasMissingProperties(out _) || matchSelection.HasNotAssignableProperties(out _))
+        {
+            return false;
+        }
+
+        descriptor = new AssignDescriptor()
+        {
+            AssignType = AssignType.NewInstance,
+            InnerSelection = matchSelection
+        };
+
+        return true;
+    }
+}