fix: member access for anonymous captures

[arika0093]

close #276

Summary by CodeRabbit

• Bug Fixes

  • Fixed member-access handling on captured objects in query projections and prevented expression compilation failures with closure variables.

• Refactor

  • Improved detection and aliasing of captured members to correctly handle nested member-access chains from outer scopes.

• Tests

  • Added tests covering member access on captured objects, captured fields, and nested member-access scenarios to ensure correct behavior.

[coderabbitai]

📝 Walkthrough

Walkthrough

Refactors analyzer capture extraction to identify root identifiers in member-access chains; adds helpers and alias-generation in SelectExprInfo for anonymous-capture member accesses; updates SelectExpr codegen to use AsEnumerable()/AsQueryable() for capture paths; adds tests for member-access on captured objects/fields.

Changes

Cohort / File(s)	Summary
Analyzer capture logic src/Linqraft.Analyzer/LocalVariableCaptureAnalyzer.cs	Extracted anonymous-object and expression capture logic into helpers (AddCapturedVariablesFromAnonymousObject, AddCapturedVariablesFromExpression, GetRootIdentifierName) and changed capture naming to use root identifiers for member-access chains.
SelectExpr codegen (core) src/Linqraft.Core/SelectExprInfo.cs	Added GenerateAnonymousCaptureMemberAccessAliases() and helpers (GetCapturePropertyName, GetRootIdentifierName, GetMemberPathFromRoot, GenerateNestedAnonymousObject) to build alias objects for anonymous captures containing member-accesses.
SelectExpr variants (integration) src/Linqraft.Core/SelectExprInfoAnonymous.cs, src/Linqraft.Core/SelectExprInfoExplicitDto.cs, src/Linqraft.Core/SelectExprInfoNamed.cs	Integrated alias-generation into anonymous-capture code paths; changed capture-enabled projection generation to use AsEnumerable().Select(...) and return AsQueryable() when captures are present.
Analyzer unit tests tests/Linqraft.Analyzer.Tests/LocalVariableCaptureAnalyzerTests.cs	Added tests asserting no diagnostics for member-access on captured request objects/fields.
Analyzer codefix tests tests/Linqraft.Analyzer.Tests/LocalVariableCaptureCodeFixProviderTests.cs	Updated two expected diagnostic argument names in test expectations ("Property" → "anotherClass").
Integration tests & models tests/Linqraft.Tests/LocalVariableCaptureTest.cs	Added three integration test cases and supporting test model types (RequestRange, NestedRequest, Commit, UserWithCommits, UserCommitDto) plus a helper data builder.

Sequence Diagram(s)

sequenceDiagram
    autonumber
    participant Dev as "Developer code\n(SelectExpr usage)"
    participant Analyzer as "LocalVariableCaptureAnalyzer\n(src/Linqraft.Analyzer)"
    participant Generator as "SelectExprInfo codegen\n(src/Linqraft.Core)"
    participant Runtime as "Runtime / Query execution"

    Dev->>Analyzer: Analyze lambda projection\n(detect identifiers, member-access roots, anonymous captures)
    Analyzer-->>Dev: Return capture metadata (root ids, capture map)
    Dev->>Generator: Generate SelectExpr method\n(include captures, anonymous aliases)
    Generator-->>Runtime: Emit projection with aliases\n(use AsEnumerable().Select(...) where captures exist)
    Runtime->>Runtime: Execute query using generated projection\n(access captured members via aliases)

Loading

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~45 minutes

Possibly related PRs

• Ver 0.3.7 #63: Overlaps capture-handling and SelectExpr codegen changes; touches anonymous-capture generation logic.
• Enhance local variable capture analysis and code fix logic #113: Modifies LocalVariableCaptureAnalyzer and SelectExprInfo similarly to refine member-access/root-identifier extraction.
• WIP: codebase refactoring #115: Adds helpers and handling for anonymous-object/member-access captures that are conceptually aligned with this change.

Poem

🐇
I hopped through nodes and followed roots,
found names where nested member shoots.
I stitched small aliases, neat and spry,
now captures hop and queries fly. 🥕

🚥 Pre-merge checks | ✅ 4 | ❌ 1

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 19.23% which is insufficient. The required threshold is 80.00%.	Write docstrings for the functions missing them to satisfy the coverage threshold.

✅ Passed checks (4 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title 'fix: member access for anonymous captures' clearly and concisely describes the main change: fixing member access handling for captured objects in anonymous captures.
Linked Issues check	✅ Passed	The PR directly addresses issue #276 by enabling member access (FromDate, ToDate) on captured objects passed via anonymous capture parameters, fixing LQRE001 diagnostics.
Out of Scope Changes check	✅ Passed	All code changes focus on member access handling for anonymous captures: refactoring capture variable extraction, adding alias generation for member accesses, updating query compilation, and adding comprehensive tests—all in scope.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing touches

• 📝 Generate docstrings

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment
• Commit unit tests in branch fix/capture-object-pattern

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 0969cbd0d8

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Handle nested member access when building capture aliases

The alias generator only records the terminal member name (memberAccess.Name) for each capture and ignores any intermediate segments in the member-access chain. That means a capture like new { request.Inner.FromDate } will produce var request = new { FromDate = captureObj.FromDate }, but the select expression still refers to request.Inner.FromDate, so the generated code won’t compile because request has no Inner property. This regression is introduced by the new member-access aliasing logic and would affect any capture that uses nested member access.

Useful? React with 👍 / 👎.

[coderabbitai]

Actionable comments posted: 0

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (2)

src/Linqraft.Core/SelectExprInfoNamed.cs (1)

184-258: ⚠️ Potential issue | 🟡 Minor

Gate AsEnumerable() to anonymous captures only. The current code unconditionally applies AsEnumerable() to all captures, but the justification in the comment—"avoid expression tree compilation with dynamic"—applies only to anonymous type captures where dynamic is used. Non-anonymous captures are cast to their actual type and do not require client-side evaluation. Applying AsEnumerable() universally forces unnecessary materialization of the entire sequence into memory. Consider moving the AsEnumerable() call inside the if (isAnonymousType) block:

Suggested refactor

if (isAnonymousType && CaptureArgumentType != null)
{
    // ... dynamic extraction ...
    sb.Append(GenerateAnonymousCaptureMemberAccessAliases());
    sb.AppendLine(
        $"    var converted = matchedQuery.AsEnumerable().Select({LambdaParameterName} => new {dtoName}"
    );
}
else
{
    // For non-anonymous types, use direct Select without AsEnumerable
    var captureTypeName = CaptureArgumentType?.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat) ?? "object";
    sb.AppendLine($"    var capture = ({captureTypeName})captureParam;");
    sb.AppendLine(
        $"    var converted = matchedQuery.Select({LambdaParameterName} => new {dtoName}"
    );
}

src/Linqraft.Core/SelectExprInfoAnonymous.cs (1)

109-169: ⚠️ Potential issue | 🟠 Major

Align SelectExprInfoAnonymous with Named/Explicit paths to avoid CS1963 in expression trees when using captures.

When the source is IQueryable and captures with dynamic aliases are involved, property assignments that reference the aliases will create dynamic member access operations inside the expression tree, triggering CS1963. SelectExprInfoNamed and SelectExprInfoExplicitDto already handle this by calling .AsEnumerable().Select() instead of .Select() directly. Apply the same fix to SelectExprInfoAnonymous for consistency and to avoid expression tree compilation with dynamic members.

🛠️ Suggested fix (align anonymous path with enumerable fallback)

-            sb.AppendLine($"    var converted = matchedQuery.Select({LambdaParameterName} => new");
+            sb.AppendLine($"    var converted = matchedQuery.AsEnumerable().Select({LambdaParameterName} => new");

For methods with captures, add conversion back to the appropriate return type:

-        sb.AppendLine($"    return converted as object as {returnTypePrefix}<TResult>;");
+        if (hasCapture)
+        {
+            sb.AppendLine($"    return converted.AsQueryable() as object as {returnTypePrefix}<TResult>;");
+        }
+        else
+        {
+            sb.AppendLine($"    return converted as object as {returnTypePrefix}<TResult>;");
+        }

🧹 Nitpick comments (2)

src/Linqraft.Core/SelectExprInfoExplicitDto.cs (1)

525-585: Gate AsEnumerable() to the anonymous-type capture path where dynamic code is generated.

The code applies AsEnumerable() unconditionally to all captures (line 552), but the justification in the comment—"avoid expression tree compilation with dynamic"—only applies when isAnonymousType is true. Non-anonymous captures use straightforward casting without dynamic operations and don't require this fallback. Consider wrapping the AsEnumerable() call to apply only when handling anonymous types or when GenerateAnonymousCaptureMemberAccessAliases() emits code, to preserve provider translation for simpler capture scenarios.

src/Linqraft.Core/SelectExprInfo.cs (1)

187-208: Consider using CodeFormatter.IndentSpaces for consistent indentation.

The generated code uses hardcoded 4-space indentation (e.g., " var", " {", " "), whereas the rest of this file uses CodeFormatter.IndentSpaces(indents) for consistent formatting. If the generated alias code needs to align with surrounding generated code, consider parameterizing the indentation level.

♻️ Example refactor to use CodeFormatter

-    protected string GenerateAnonymousCaptureMemberAccessAliases()
+    protected string GenerateAnonymousCaptureMemberAccessAliases(int baseIndent = 1)
     {
         // ... existing code ...
         
+        var spaces = CodeFormatter.IndentSpaces(baseIndent);
+        var innerSpaces = CodeFormatter.IndentSpaces(baseIndent + CodeFormatter.IndentSize);
+        
         var sb = new StringBuilder();
         foreach (var kvp in aliasMap)
         {
             var rootName = kvp.Key;
             var members = kvp.Value;
-            sb.AppendLine($"    var {rootName} = new");
-            sb.AppendLine("    {");
+            sb.AppendLine($"{spaces}var {rootName} = new");
+            sb.AppendLine($"{spaces}{{");
             // ... rest of formatting ...
         }

[arika0093]

@copilot fix all review comments

[Copilot]

@arika0093 I've opened a new pull request, #279, to work on those changes. Once the pull request is ready, I'll request review from you.

[coderabbitai]

Actionable comments posted: 1

🤖 Fix all issues with AI agents

In `@src/Linqraft.Core/SelectExprInfo.cs`:
- Around line 203-219: The loop that walks pathParts and casts child to
Dictionary<string, object> can throw InvalidCastException when a shorter path
was previously added as a leaf (a string) and a longer path reuses that prefix;
update the logic around current, child, pathParts and captureName so you check
the runtime type before casting: if child is already a Dictionary<string,
object> proceed normally, but if child is a leaf (e.g., string) replace it with
a new Dictionary<string, object> that preserves the previous leaf value under a
reserved key (for example "__leaf") and then continue; similarly, when setting
the lastPart, if current[lastPart] already exists and is a Dictionary, write the
captureName into that dictionary under "__leaf" instead of overwriting the
dictionary. This change should be applied to the code using variables current,
child, pathParts and captureName to avoid InvalidCastException.