feat: Improve formatting of generated source code for nested structures (#145)

Copilot · arika0093 · arika0093 · commit ad79231a00d9 · 2025-11-25T05:36:34.000Z
* Initial plan * feat: Improve formatting of generated source code for nested structures Co-authored-by: arika0093 <4524647+arika0093@users.noreply.github.com> * feat: Improve formatting of generated source code for nested structures Co-authored-by: arika0093 <4524647+arika0093@users.noreply.github.com> * fix: Improve nested Select formatting with proper indentation levels Co-authored-by: arika0093 <4524647+arika0093@users.noreply.github.com> --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: arika0093 <4524647+arika0093@users.noreply.github.com> (cherry picked from commit 58b8170)
diff --git a/src/Linqraft.Core/RoslynHelpers/RoslynTypeHelper.cs b/src/Linqraft.Core/RoslynHelpers/RoslynTypeHelper.cs
@@ -193,7 +193,7 @@ public static bool ContainsSelectInvocation(ExpressionSyntax expression)
             return false;
 
         return expression
-            .DescendantNodes()
+            .DescendantNodesAndSelf()
             .OfType<InvocationExpressionSyntax>()
             .Any(inv =>
                 inv.Expression is MemberAccessExpressionSyntax ma
@@ -212,7 +212,7 @@ public static bool ContainsSelectManyInvocation(ExpressionSyntax expression)
             return false;
 
         return expression
-            .DescendantNodes()
+            .DescendantNodesAndSelf()
             .OfType<InvocationExpressionSyntax>()
             .Any(inv =>
                 inv.Expression is MemberAccessExpressionSyntax ma
diff --git a/src/Linqraft.Core/SelectExprInfo.cs b/src/Linqraft.Core/SelectExprInfo.cs
@@ -236,25 +236,7 @@ protected string GeneratePropertyAssignment(DtoProperty property, int indents)
         // For nested structure cases
         if (property.NestedStructure is not null)
         {
-            // General approach: Replace any anonymous type creation in the expression with the DTO
-            // This works for direct anonymous types, ternary operators, and any other expression structure
-            var anonymousCreation = syntax
-                .DescendantNodesAndSelf()
-                .OfType<AnonymousObjectCreationExpressionSyntax>()
-                .FirstOrDefault();
-
-            if (anonymousCreation != null)
-            {
-                // Convert the expression by replacing the anonymous type with the DTO
-                return ConvertExpressionWithAnonymousTypeToDto(
-                    syntax,
-                    anonymousCreation,
-                    property.NestedStructure,
-                    indents
-                );
-            }
-
-            // Check if this contains SelectMany
+            // Check if this contains SelectMany first (it's more specific)
             if (RoslynTypeHelper.ContainsSelectManyInvocation(syntax))
             {
                 // For nested SelectMany (collection flattening) case
@@ -275,19 +257,44 @@ protected string GeneratePropertyAssignment(DtoProperty property, int indents)
                 return convertedSelectMany;
             }
 
-            // For nested Select (collection) case
-            var convertedSelect = ConvertNestedSelectWithRoslyn(
-                syntax,
-                property.NestedStructure,
-                indents
-            );
-            // Debug: Check if conversion was performed correctly
-            if (convertedSelect == expression && RoslynTypeHelper.ContainsSelectInvocation(syntax))
+            // Check if this contains Select - use dedicated formatting for better output
+            if (RoslynTypeHelper.ContainsSelectInvocation(syntax))
             {
-                // If conversion was not performed, leave the original expression as a comment
-                return $"{convertedSelect} /* CONVERSION FAILED: {property.Name} */";
+                // For nested Select (collection) case - handles both anonymous and named types
+                var convertedSelect = ConvertNestedSelectWithRoslyn(
+                    syntax,
+                    property.NestedStructure,
+                    indents
+                );
+                // Debug: Check if conversion was performed correctly
+                if (convertedSelect == expression)
+                {
+                    // If conversion was not performed, leave the original expression as a comment
+                    return $"{convertedSelect} /* CONVERSION FAILED: {property.Name} */";
+                }
+                return convertedSelect;
+            }
+
+            // For other cases with anonymous types (e.g., ternary operators, direct anonymous types)
+            // Replace any anonymous type creation in the expression with the DTO
+            var anonymousCreation = syntax
+                .DescendantNodesAndSelf()
+                .OfType<AnonymousObjectCreationExpressionSyntax>()
+                .FirstOrDefault();
+
+            if (anonymousCreation != null)
+            {
+                // Convert the expression by replacing the anonymous type with the DTO
+                return ConvertExpressionWithAnonymousTypeToDto(
+                    syntax,
+                    anonymousCreation,
+                    property.NestedStructure,
+                    indents
+                );
             }
-            return convertedSelect;
+
+            // Fallback: return the original expression
+            return expression;
         }
         // If nullable operator is used, convert to explicit null check
         if (
@@ -426,24 +433,29 @@ protected string ConvertExpressionWithAnonymousTypeToDto(
         int indents
     )
     {
+        var spaces = CodeFormatter.IndentSpaces(indents);
+        var innerSpaces = CodeFormatter.IndentSpaces(indents + CodeFormatter.IndentSize);
         var nestedClassName = GetClassName(nestedStructure);
         var nestedDtoName = string.IsNullOrEmpty(nestedClassName)
             ? ""
             : GetNestedDtoFullName(nestedClassName);
 
-        // Generate the DTO object creation to replace the anonymous type
-        // We need to preserve indentation based on where the anonymous type appears
+        // Generate the DTO object creation to replace the anonymous type with proper formatting
         var propertyAssignments = new List<string>();
         foreach (var prop in nestedStructure.Properties)
         {
-            var assignment = GeneratePropertyAssignment(prop, 0);
-            propertyAssignments.Add($"    {prop.Name} = {assignment}");
+            var assignment = GeneratePropertyAssignment(prop, indents + CodeFormatter.IndentSize);
+            propertyAssignments.Add($"{innerSpaces}{prop.Name} = {assignment}");
         }
         var propertiesCode = string.Join($",{CodeFormatter.DefaultNewLine}", propertyAssignments);
 
-        // Build the DTO creation as a compact single-line or multi-line depending on complexity
-        var dtoCreation =
-            $"new {nestedDtoName}{CodeFormatter.DefaultNewLine}{{{CodeFormatter.DefaultNewLine}{propertiesCode}{CodeFormatter.DefaultNewLine}}}";
+        // Build the DTO creation with proper formatting
+        var dtoCreation = $$"""
+            new {{nestedDtoName}}
+            {{spaces}}{
+            {{propertiesCode}}
+            {{spaces}}}
+            """;
 
         // Remove comments from syntax before processing
         var cleanSyntax = RemoveComments(syntax);
@@ -469,26 +481,29 @@ int indents
     )
     {
         var spaces = CodeFormatter.IndentSpaces(indents);
+        var innerSpaces = CodeFormatter.IndentSpaces(indents + CodeFormatter.IndentSize);
         var nestedClassName = GetClassName(nestedStructure);
         // For anonymous types (empty class name), don't use namespace qualification
         var nestedDtoName = string.IsNullOrEmpty(nestedClassName)
             ? ""
             : GetNestedDtoFullName(nestedClassName);
 
-        // Generate property assignments for nested DTO
+        // Generate property assignments for nested DTO with proper formatting
         var propertyAssignments = new List<string>();
         foreach (var prop in nestedStructure.Properties)
         {
-            var assignment = GeneratePropertyAssignment(prop, indents + CodeFormatter.IndentSize);
-            propertyAssignments.Add(
-                $"{spaces}{CodeFormatter.Indent(1)}{prop.Name} = {assignment},"
+            var assignment = GeneratePropertyAssignment(
+                prop,
+                indents + CodeFormatter.IndentSize * 2
             );
+            propertyAssignments.Add($"{innerSpaces}{prop.Name} = {assignment}");
         }
-        var propertiesCode = string.Join(CodeFormatter.DefaultNewLine, propertyAssignments);
+        var propertiesCode = string.Join($",{CodeFormatter.DefaultNewLine}", propertyAssignments);
 
-        // Build the new DTO object creation expression
+        // Build the new DTO object creation expression with proper formatting
         var code = $$"""
-            new {{nestedDtoName}} {
+            new {{nestedDtoName}}
+            {{spaces}}{
             {{propertiesCode}}
             {{spaces}}}
             """;
@@ -505,6 +520,7 @@ int indents
     )
     {
         var spaces = CodeFormatter.IndentSpaces(indents);
+        var innerSpaces = CodeFormatter.IndentSpaces(indents + CodeFormatter.IndentSize);
         var nestedClassName = GetClassName(nestedStructure);
         // For anonymous types (empty class name), don't use namespace qualification
         var nestedDtoName = string.IsNullOrEmpty(nestedClassName)
@@ -535,18 +551,25 @@ int indents
             "."
         );
 
-        // Generate property assignments for nested DTO
+        // Generate property assignments for nested DTO with proper formatting
+        // Properties should be indented two levels from the base (one for Select block, one for properties)
+        var propertyIndentSpaces = CodeFormatter.IndentSpaces(indents + CodeFormatter.IndentSize * 2);
         var propertyAssignments = new List<string>();
         foreach (var prop in nestedStructure.Properties)
         {
-            var assignment = GeneratePropertyAssignment(prop, indents + CodeFormatter.IndentSize);
-            propertyAssignments.Add(
-                $"{spaces}{CodeFormatter.Indent(1)}{prop.Name} = {assignment},"
+            var assignment = GeneratePropertyAssignment(
+                prop,
+                indents + CodeFormatter.IndentSize * 2
             );
+            propertyAssignments.Add($"{propertyIndentSpaces}{prop.Name} = {assignment}");
         }
-        var propertiesCode = string.Join(CodeFormatter.DefaultNewLine, propertyAssignments);
+        var propertiesCode = string.Join($",{CodeFormatter.DefaultNewLine}", propertyAssignments);
 
-        // Build the Select expression
+        // Format chained methods with proper indentation (one level from base)
+        var formattedChainedMethods = FormatChainedMethods(chainedMethods, innerSpaces);
+
+        // Build the Select expression with proper formatting
+        // The .Select, {, }, and chained methods should all be indented one level from the property assignment
         if (hasNullableAccess)
         {
             // Determine default value
@@ -559,23 +582,78 @@ int indents
                 );
 
             var code = $$"""
-                {{baseExpression}} != null ? {{baseExpression}}.Select({{paramName}} => new {{nestedDtoName}} {
+                {{baseExpression}} != null ? {{baseExpression}}
+                {{innerSpaces}}.Select({{paramName}} => new {{nestedDtoName}}
+                {{innerSpaces}}{
                 {{propertiesCode}}
-                {{spaces}}}){{chainedMethods}} : {{defaultValue}}
+                {{innerSpaces}}}){{formattedChainedMethods}} : {{defaultValue}}
                 """;
             return code;
         }
         else
         {
             var code = $$"""
-                {{baseExpression}}.Select({{paramName}} => new {{nestedDtoName}} {
+                {{baseExpression}}
+                {{innerSpaces}}.Select({{paramName}} => new {{nestedDtoName}}
+                {{innerSpaces}}{
                 {{propertiesCode}}
-                {{spaces}}}){{chainedMethods}}
+                {{innerSpaces}}}){{formattedChainedMethods}}
                 """;
             return code;
         }
     }
 
+    /// <summary>
+    /// Formats chained method calls (like .ToList()) with proper indentation
+    /// </summary>
+    private static string FormatChainedMethods(string chainedMethods, string spaces)
+    {
+        if (string.IsNullOrEmpty(chainedMethods))
+            return "";
+
+        // Normalize whitespace from chained method calls
+        var normalized = System.Text.RegularExpressions.Regex.Replace(
+            chainedMethods.Trim(),
+            @"\s+",
+            ""
+        );
+
+        // Each method call should be on a new line with proper indentation
+        var result = new StringBuilder();
+        var currentMethod = new StringBuilder();
+        var parenDepth = 0;
+
+        foreach (var c in normalized)
+        {
+            currentMethod.Append(c);
+
+            if (c == '(')
+                parenDepth++;
+            else if (c == ')')
+            {
+                parenDepth--;
+                if (parenDepth == 0)
+                {
+                    // Complete method call with parentheses
+                    result.Append(CodeFormatter.DefaultNewLine);
+                    result.Append(spaces);
+                    result.Append(currentMethod);
+                    currentMethod.Clear();
+                }
+            }
+        }
+
+        // Handle any remaining content (e.g., property access without parentheses like .Count)
+        if (currentMethod.Length > 0)
+        {
+            result.Append(CodeFormatter.DefaultNewLine);
+            result.Append(spaces);
+            result.Append(currentMethod);
+        }
+
+        return result.ToString();
+    }
+
     /// <summary>
     /// Converts nested SelectMany expressions using Roslyn syntax analysis
     /// </summary>
@@ -586,6 +664,7 @@ int indents
     )
     {
         var spaces = CodeFormatter.IndentSpaces(indents);
+        var innerSpaces = CodeFormatter.IndentSpaces(indents + CodeFormatter.IndentSize);
 
         // Use Roslyn to extract SelectMany information
         var selectManyInfo = ExtractSelectManyInfoFromSyntax(syntax);
@@ -619,21 +698,25 @@ int indents
                 ? ""
                 : GetNestedDtoFullName(nestedClassName);
 
-            // Generate property assignments for nested DTO
+            // Generate property assignments for nested DTO with proper formatting
+            // Properties should be indented two levels from the base (one for SelectMany block, one for properties)
+            var propertyIndentSpaces = CodeFormatter.IndentSpaces(indents + CodeFormatter.IndentSize * 2);
             var propertyAssignments = new List<string>();
             foreach (var prop in nestedStructure.Properties)
             {
                 var assignment = GeneratePropertyAssignment(
                     prop,
-                    indents + CodeFormatter.IndentSize
-                );
-                propertyAssignments.Add(
-                    $"{spaces}{CodeFormatter.Indent(1)}{prop.Name} = {assignment},"
+                    indents + CodeFormatter.IndentSize * 2
                 );
+                propertyAssignments.Add($"{propertyIndentSpaces}{prop.Name} = {assignment}");
             }
-            var propertiesCode = string.Join(CodeFormatter.DefaultNewLine, propertyAssignments);
+            var propertiesCode = string.Join($",{CodeFormatter.DefaultNewLine}", propertyAssignments);
+
+            // Format chained methods with proper indentation (one level from base)
+            var formattedChainedMethods = FormatChainedMethods(chainedMethods, innerSpaces);
 
-            // Build the SelectMany expression with projection
+            // Build the SelectMany expression with projection and proper formatting
+            // The .SelectMany, {, }, and chained methods should all be indented one level from the property assignment
             if (hasNullableAccess)
             {
                 var defaultValue =
@@ -645,18 +728,22 @@ int indents
                     );
 
                 var code = $$"""
-                    {{baseExpression}} != null ? {{baseExpression}}.SelectMany({{paramName}} => new {{nestedDtoName}} {
+                    {{baseExpression}} != null ? {{baseExpression}}
+                    {{innerSpaces}}.SelectMany({{paramName}} => new {{nestedDtoName}}
+                    {{innerSpaces}}{
                     {{propertiesCode}}
-                    {{spaces}}}){{chainedMethods}} : {{defaultValue}}
+                    {{innerSpaces}}}){{formattedChainedMethods}} : {{defaultValue}}
                     """;
                 return code;
             }
             else
             {
                 var code = $$"""
-                    {{baseExpression}}.SelectMany({{paramName}} => new {{nestedDtoName}} {
+                    {{baseExpression}}
+                    {{innerSpaces}}.SelectMany({{paramName}} => new {{nestedDtoName}}
+                    {{innerSpaces}}{
                     {{propertiesCode}}
-                    {{spaces}}}){{chainedMethods}}
+                    {{innerSpaces}}}){{formattedChainedMethods}}
                     """;
                 return code;
             }
