Colocate explicit DTO generation with SelectExpr files (#248)

* Initial plan

* feat: colocate explicit dtos with expressions

Co-authored-by: arika0093 <4524647+arika0093@users.noreply.github.com>

* chore: factor hash namespace prefix constant

Co-authored-by: arika0093 <4524647+arika0093@users.noreply.github.com>

* chore: refine hash namespace detection

Co-authored-by: arika0093 <4524647+arika0093@users.noreply.github.com>

* docs: reflect dto emission in generator comment

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 67d7693)

Author: Copilot

src/Linqraft.Core/GenerateSourceCodeSnippets.cs

@@ -30,13 +30,18 @@ IncrementalGeneratorPostInitializationContext context
     // Generate expression and headers
     public static string BuildExprCodeSnippetsWithHeaders(
         List<string> expressions,
-        List<string> staticFields
+        List<string> staticFields,
+        string? dtoCode = null
     )
     {
+        var dtoPart = string.IsNullOrWhiteSpace(dtoCode)
+            ? string.Empty
+            : $"{CodeFormatter.DefaultNewLine}{dtoCode}";
+
         return $$"""
             {{GenerateCommentHeaderPart()}}
             {{GenerateHeaderFlagsPart}}
-            {{BuildExprCodeSnippets(expressions, staticFields)}}
+            {{BuildExprCodeSnippets(expressions, staticFields)}}{{dtoPart}}
             """;
     }
 

src/Linqraft.SourceGenerator/SelectExprGenerator.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Linqraft.Core;
@@ -117,32 +118,66 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                     })
                     .ToList();
 
-                // Collect all DTOs from all groups and deduplicate globally
-                var allDtoClassInfos = new List<GenerateDtoClassInfo>();
+                var hashNamespaceDtoClassInfos = new List<GenerateDtoClassInfo>();
+                var emittedDtoFullNames = new HashSet<string>();
+
                 foreach (var exprGroup in exprGroups)
                 {
+                    var groupDtos = new List<GenerateDtoClassInfo>();
+
                     foreach (var expr in exprGroup.Exprs)
                     {
                         var classInfos = expr.Info.GenerateDtoClasses();
-                        allDtoClassInfos.AddRange(classInfos);
+                        foreach (var classInfo in classInfos)
+                        {
+                            // DTOs in hash-named namespaces can stay in the shared file
+                            if (IsHashNamespaceDto(classInfo.Namespace))
+                            {
+                                hashNamespaceDtoClassInfos.Add(classInfo);
+                                continue;
+                            }
+
+                            // Deduplicate by FullName and keep the first occurrence in this group
+                            if (emittedDtoFullNames.Add(classInfo.FullName))
+                            {
+                                groupDtos.Add(classInfo);
+                            }
+                        }
                     }
+
+                    exprGroup.DtoClasses = groupDtos;
                 }
 
-                // Generate all DTOs in a single shared source file
+                // Generate DTOs that remain in the shared file (hash namespaces)
                 var dtoCode = GenerateSourceCodeSnippets.BuildGlobalDtoCodeSnippet(
-                    allDtoClassInfos,
+                    hashNamespaceDtoClassInfos,
                     config
                 );
                 if (!string.IsNullOrEmpty(dtoCode))
                 {
                     spc.AddSource("GeneratedDtos.g.cs", dtoCode);
                 }
 
-                // Generate code for expression methods (without DTOs)
+                // Generate code for expression methods (with co-located DTOs)
                 foreach (var exprGroup in exprGroups)
                 {
                     exprGroup.GenerateCodeWithoutDtos(spc);
                 }
+
+                static bool IsHashNamespaceDto(string? namespaceName)
+                {
+                    const string HashNamespacePrefix = "LinqraftGenerated_";
+
+                    if (namespaceName is not { Length: > 0 } ns)
+                    {
+                        return false;
+                    }
+
+                    var parts = ns.Split('.');
+                    return parts.Any(p =>
+                        p.StartsWith(HashNamespacePrefix, StringComparison.Ordinal)
+                    );
+                }
             }
         );
     }

src/Linqraft.SourceGenerator/SelectExprGroups.cs

@@ -11,6 +11,8 @@ internal class SelectExprGroups
 {
     public required List<SelectExprLocations> Exprs { get; set; }
 
+    public List<GenerateDtoClassInfo> DtoClasses { get; set; } = [];
+
     public required LinqraftConfiguration Configuration { get; set; }
 
     public required string TargetNamespace
@@ -43,7 +45,7 @@ public string GetUniqueId()
         return $"{targetNsReplaced}_{filenameReplaced}";
     }
 
-    // Generate source code without DTOs (for global DTO generation)
+    // Generate source code for expressions and co-located DTOs
     public virtual void GenerateCodeWithoutDtos(SourceProductionContext context)
     {
         try
@@ -79,12 +81,24 @@ public virtual void GenerateCodeWithoutDtos(SourceProductionContext context)
                 }
             }
 
+            var dtoCode = DtoClasses.Count > 0
+                ? GenerateSourceCodeSnippets.BuildDtoCodeSnippetsGroupedByNamespace(
+                    DtoClasses,
+                    Configuration
+                )
+                : string.Empty;
+
             // Generate interceptor-based expression methods
-            if (selectExprMethods.Count > 0 || staticFields.Count > 0)
+            if (
+                selectExprMethods.Count > 0
+                || staticFields.Count > 0
+                || !string.IsNullOrEmpty(dtoCode)
+            )
             {
                 var sourceCode = GenerateSourceCodeSnippets.BuildExprCodeSnippetsWithHeaders(
                     selectExprMethods,
-                    staticFields
+                    staticFields,
+                    dtoCode
                 );
                 var uniqueId = GetUniqueId();
                 context.AddSource($"GeneratedExpression_{uniqueId}.g.cs", sourceCode);

tests/Linqraft.Tests/ExplicitDtoLocationTest.cs

@@ -0,0 +1,44 @@
+using System;
+using System.IO;
+
+namespace Linqraft.Tests;
+
+public class ExplicitDtoLocationTest
+{
+    [Fact]
+    public void Explicit_dto_classes_are_emitted_with_expression_file()
+    {
+        var projectDir = GetProjectDirectory();
+        var generatorDir = Path.Combine(
+            projectDir,
+            ".generated",
+            "Linqraft.SourceGenerator",
+            "Linqraft.SelectExprGenerator"
+        );
+
+        var expressionFile = Path.Combine(
+            generatorDir,
+            "GeneratedExpression_Linqraft_Tests_ExplicitDtoComprehensiveTest.g.cs"
+        );
+        var dtoFile = Path.Combine(generatorDir, "GeneratedDtos.g.cs");
+
+        File.Exists(expressionFile).ShouldBeTrue();
+
+        var expressionCode = File.ReadAllText(expressionFile);
+        expressionCode.ShouldContain("partial class SimpleNullableDto");
+        expressionCode.ShouldContain("partial class NullConditionalDto");
+
+        if (File.Exists(dtoFile))
+        {
+            var dtoCode = File.ReadAllText(dtoFile);
+            dtoCode.ShouldNotContain("partial class SimpleNullableDto");
+            dtoCode.ShouldNotContain("partial class NullConditionalDto");
+        }
+    }
+
+    private static string GetProjectDirectory()
+    {
+        var baseDir = AppContext.BaseDirectory;
+        return Path.GetFullPath(Path.Combine(baseDir, "..", "..", ".."));
+    }
+}