fix: handle nested member access in anonymous capture aliases (#279)

* Initial plan

* fix: handle nested member access in anonymous capture aliases

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

* refactor: improve code clarity per review feedback

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>

Author: Copilot

src/Linqraft.Core/SelectExprInfo.cs

@@ -154,22 +154,22 @@ protected string GenerateAnonymousCaptureMemberAccessAliases()
 
             if (initializer.Expression is MemberAccessExpressionSyntax memberAccess)
             {
-                var rootName = GetRootIdentifierName(memberAccess.Expression);
+                var rootName = GetRootIdentifierName(memberAccess);
                 if (rootName == null)
                 {
                     continue;
                 }
 
-                var memberName = memberAccess.Name.Identifier.Text;
-                var captureName = capturePropertyName ?? memberName;
+                var memberPath = GetMemberPathFromRoot(memberAccess, rootName);
+                var captureName = capturePropertyName ?? memberAccess.Name.Identifier.Text;
 
                 if (!aliasMap.TryGetValue(rootName, out var members))
                 {
                     members = new List<(string MemberName, string CapturePropertyName)>();
                     aliasMap[rootName] = members;
                 }
 
-                members.Add((memberName, captureName));
+                members.Add((memberPath, captureName));
             }
         }
 
@@ -189,27 +189,70 @@ protected string GenerateAnonymousCaptureMemberAccessAliases()
         {
             var rootName = kvp.Key;
             var members = kvp.Value;
-            sb.AppendLine($"    var {rootName} = new");
-            sb.AppendLine("    {");
-
-            var usedMemberNames = new HashSet<string>();
+            
+            // Build a tree structure for nested member paths
+            var tree = new Dictionary<string, object>();
             foreach (var memberPair in members)
             {
-                var memberName = memberPair.MemberName;
+                var memberPath = memberPair.MemberName;
                 var captureName = memberPair.CapturePropertyName;
-                if (!usedMemberNames.Add(memberName))
+                
+                var pathParts = memberPath.Split('.');
+                var current = tree;
+                
+                for (int i = 0; i < pathParts.Length - 1; i++)
                 {
-                    continue;
+                    var part = pathParts[i];
+                    if (!current.TryGetValue(part, out var child))
+                    {
+                        child = new Dictionary<string, object>();
+                        current[part] = child;
+                    }
+                    current = (Dictionary<string, object>)child;
+                }
+                
+                // Add the leaf node with the capture name
+                var lastPart = pathParts[^1];
+                if (!current.ContainsKey(lastPart))
+                {
+                    current[lastPart] = captureName;
                 }
-                sb.AppendLine($"        {memberName} = captureObj.{captureName},");
             }
-
+            
+            // Generate the nested anonymous object
+            sb.AppendLine($"    var {rootName} = new");
+            sb.AppendLine("    {");
+            GenerateNestedAnonymousObject(sb, tree, 2, "captureObj");
             sb.AppendLine("    };");
         }
 
         return sb.ToString();
     }
 
+    private static void GenerateNestedAnonymousObject(StringBuilder sb, Dictionary<string, object> tree, int indentLevel, string captureObjName)
+    {
+        var indent = new string(' ', indentLevel * 4);
+        foreach (var kvp in tree)
+        {
+            var memberName = kvp.Key;
+            var value = kvp.Value;
+            
+            if (value is string captureName)
+            {
+                // Leaf node: simple assignment
+                sb.AppendLine($"{indent}{memberName} = {captureObjName}.{captureName},");
+            }
+            else if (value is Dictionary<string, object> nested)
+            {
+                // Nested node: create nested anonymous object
+                sb.AppendLine($"{indent}{memberName} = new");
+                sb.AppendLine($"{indent}{{");
+                GenerateNestedAnonymousObject(sb, nested, indentLevel + 1, captureObjName);
+                sb.AppendLine($"{indent}}},");
+            }
+        }
+    }
+
     private static string? GetCapturePropertyName(AnonymousObjectMemberDeclaratorSyntax initializer)
     {
         if (initializer.NameEquals != null)
@@ -235,6 +278,30 @@ protected string GenerateAnonymousCaptureMemberAccessAliases()
         };
     }
 
+    private static string GetMemberPathFromRoot(ExpressionSyntax expression, string rootName)
+    {
+        var parts = new List<string>();
+        var current = expression;
+
+        while (current is MemberAccessExpressionSyntax memberAccess)
+        {
+            parts.Insert(0, memberAccess.Name.Identifier.Text);
+            current = memberAccess.Expression;
+        }
+
+        // If current is the root identifier, we've collected all member parts
+        if (current is IdentifierNameSyntax identifier && identifier.Identifier.Text == rootName)
+        {
+            return string.Join(".", parts);
+        }
+
+        // Fallback: This should not happen in normal usage since we only call this method
+        // after verifying GetRootIdentifierName succeeds. Return the last member name as
+        // a safe fallback to avoid breaking the generation if the expression structure
+        // is unexpected (e.g., complex expressions that aren't simple member chains).
+        return parts.Count > 0 ? parts[^1] : "";
+    }
+
     /// <summary>
     /// Gets the full name for a nested DTO class using the structure.
     /// This allows derived classes to compute namespace-based naming using the structure's hash.

tests/Linqraft.Tests/LocalVariableCaptureTest.cs

@@ -256,6 +256,38 @@ public void IEnumerable_WithCapturedVariable()
         first.NewValue.ShouldBe(110);
     }
 
+    [Fact]
+    public void Case3_NestedMemberAccess_InCapturedFields()
+    {
+        var request = new NestedRequest
+        {
+            Range = new RequestRange
+            {
+                FromDate = new DateTimeOffset(2024, 1, 1, 0, 0, 0, TimeSpan.Zero),
+                ToDate = new DateTimeOffset(2024, 1, 3, 0, 0, 0, TimeSpan.Zero),
+            }
+        };
+        var users = BuildUsers();
+
+        var converted = users
+            .AsQueryable()
+            .SelectExpr<UserWithCommits, UserCommitDto>(
+                u => new
+                {
+                    u.Id,
+                    CommitCount = u.Commits.Count(c =>
+                        request.Range.FromDate <= c.Created && c.Created <= request.Range.ToDate
+                    ),
+                },
+                new { request.Range.FromDate, request.Range.ToDate }
+            )
+            .ToList();
+
+        converted.Count.ShouldBe(2);
+        converted[0].CommitCount.ShouldBe(1);
+        converted[1].CommitCount.ShouldBe(0);
+    }
+
     private static List<UserWithCommits> BuildUsers() =>
     [
         new()
@@ -319,6 +351,11 @@ internal class RequestRange
     public DateTimeOffset ToDate { get; set; }
 }
 
+internal class NestedRequest
+{
+    public RequestRange Range { get; set; } = new();
+}
+
 internal class Commit
 {
     public DateTimeOffset Created { get; set; }