Fix nested SelectExpr code generation: parent class qualification, array types, and comment verbosity

[Copilot]

Summary

This PR fixes three issues with nested SelectExpr code generation as reported in the issue:

✅ Issue 1: Missing Parent Class Qualification

Problem: When using nested SelectExpr with explicit DTO types declared inside a parent class, the generated code referenced them without the parent class qualifier, causing compilation errors.

Solution:

• Updated DtoProperty.cs to extract parent class information from the syntax tree when the type symbol is not available (error type)
• Simplified logic in SelectExprInfo.cs to use ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat) for fully qualified names
• Updated GenerateDtoClassInfo.cs to preserve global:: prefix in generic type arguments

Example: NestedItemDtoEnumerable → global::MinRepro.Issue_NestedSelectExprTest.NestedItemDtoEnumerable

✅ Issue 2: Array Property Type Missing [] Suffix

Problem: When using .ToArray() with nested SelectExpr, the generated DTO property type was missing the array suffix [].

Solution:

• Created IsArrayType helper method in GenerateDtoClassInfo.cs that checks:
  1. Type symbol (IArrayTypeSymbol)
  2. Type string pattern (ends with [])
  3. Original expression syntax (ends with .ToArray())

Example: NestedItemDtoArray → NestedItemDtoArray[]

✅ Issue 3: Verbose Documentation Comments

Problem: SelectExpr method calls in documentation comments included full generic type arguments and lambda bodies, making them overly verbose.

Solution:

• Updated AbbreviateAllMethodCalls in DtoProperty.cs to detect and skip generic type arguments when abbreviating method calls
• Extracted SkipGenericTypeArguments helper method for better code organization
• Comments now follow the same abbreviated pattern as regular Select calls

Example: SelectExpr<TIn,TResult>(lambda) → SelectExpr(...)

Review Comments Addressed

Test File Updates

• Renamed test file to Issue217_NestedSelectExprTest.cs per naming convention
• Removed explicit qualifiers from SelectExpr calls (e.g., Issue_NestedSelectExprTest.NestedItemDtoEnumerable → NestedItemDtoEnumerable)
• Added partial class declarations for all nested DTOs to make them visible without qualification

Code Quality Improvements

• Enhanced comment on IsArrayType helper to clarify that .ToArray() detection is a necessary compromise when semantic model information is unavailable
• Extracted SkipGenericTypeArguments helper method from AbbreviateAllMethodCalls for better separation of concerns

Important Note on Partial Class Declarations

Partial class declarations are required when using unqualified DTO type names in nested SelectExpr calls. Without them, the generator cannot determine if the DTO should be nested inside a parent class or placed at the namespace level, and defaults to namespace level placement.

Two approaches work:

1. With partial declarations (recommended): Declare partial classes inside the parent class, allowing unqualified type names
2. With qualified names: Use fully qualified names like Issue_NestedSelectExprTest.NestedItemDtoEnumerable in the SelectExpr type arguments

The test demonstrates approach #1 for cleaner code.

Testing

• All 130 tests passing ✅
• Test case validates unqualified DTO type references work correctly with partial class declarations
• No regressions in existing tests

Original prompt

---

This section details on the original issue you should resolve

<issue_title>bug: The code generated for nested SelectExpr is still insufficient</issue_title>
<issue_description>### Minimal Reproducible Example

using System.Collections.Generic;
using System.Linq;

namespace MinRepro;

public partial class Issue_NestedSelectExprTest
{
    private readonly List<NestedEntity> TestData = [];

    public void NestedSelectExpr_WithExplicitDtoTypes_ShouldWork()
    {
        var query = TestData.AsQueryable();

        var result = query
            .SelectExpr<NestedEntity, NestedEntityDto>(x => new
            {
                x.Id,
                x.Name,
                // error: ItemsEnumerable should be IEnumerable<NestedItemDtoEnumerable>
                ItemsEnumerable = x.Items.SelectExpr<NestedItem, NestedItemDtoEnumerable>(i => new
                {
                    i.Id,
                }),
                ItemsList = x
                    .Items.SelectExpr<NestedItem, NestedItemDtoList>(i => new { i.Id })
                    .ToList(),
                // error: ItemsArray should be NestedItemDtoArray[]
                ItemsArray = x
                    .Items.SelectExpr<NestedItem, NestedItemDtoArray>(i => new
                    {
                        i.Id,
                        i.Title,
                        SubItem = i.SubItems.Select(si => new { si.Id, si.Value }),
                        // error: SubItemWithExpr should be IEnumerable<NestedSubItemDto>
                        SubItemWithExpr = i.SubItems.SelectExpr<NestedSubItem, NestedSubItemDto>(
                            si => new { si.Id, si.Value }
                        ),
                    })
                    .ToArray(),
            })
            .ToList();
    }

    internal class NestedEntity
    {
        public int Id { get; set; }
        public string Name { get; set; } = null!;
        public List<NestedItem> Items { get; set; } = [];
    }

    internal class NestedItem
    {
        public int Id { get; set; }
        public string Title { get; set; } = null!;
        public List<NestedSubItem> SubItems { get; set; } = [];
    }

    internal class NestedSubItem
    {
        public int Id { get; set; }
        public string Value { get; set; } = null!;
    }

    internal partial class NestedEntityDto;
}

Generated Output

// <auto-generated>
// This file is auto-generated by Linqraft.
//   Linqraft Version  : 0.7.0-alpha.8+19d8834e72
//   Linqraft Build at : 2025-12-06 21:57:55
//   Code Generated at : 2025-12-06 22:22:54
// </auto-generated>
#nullable enable
#pragma warning disable IDE0060
#pragma warning disable CS8601
#pragma warning disable CS8602
#pragma warning disable CS8603
#pragma warning disable CS8604
#pragma warning disable CS8618
using System;
using System.Linq;
using System.Collections.Generic;
using System.Collections.Immutable;
namespace Linqraft
{
    file static partial class GeneratedExpression
    {
        /// <summary>
        /// generated select expression method NestedEntityDto (explicit) <br/>
        /// at Program.cs(15,14)
        /// </summary>
        [global::System.Runtime.CompilerServices.InterceptsLocationAttribute(1, "kJHmE9posoDZvhZUfQzD2lMBAABQcm9ncmFtLmNz")]
        public static IQueryable<TResult> SelectExpr_785FB844_EC5ADE1A<TIn, TResult>(
            this IQueryable<TIn> query, Func<TIn, object> selector)
        {
            var matchedQuery = query as object as IQueryable<global::MinRepro.Issue_NestedSelectExprTest.NestedEntity>;
            var converted = matchedQuery.Select(x => new global::MinRepro.Issue_NestedSelectExprTest.NestedEntityDto
            {
                Id = x.Id,
                Name = x.Name,
                ItemsEnumerable = x.Items
                    .Select(i => new global::MinRepro.NestedItemDtoEnumerable
                    {
                        Id = i.Id
                    }),
                ItemsList = x.Items
                    .Select(i => new global::MinRepro.NestedItemDtoList
                    {
                        Id = i.Id
                    })
                    .ToList(),
                ItemsArray = x.Items
                    .Select(i => new global::MinRepro.NestedItemDtoArray
                    {
                        Id = i.Id,
                        Title = i.Title,
                        SubItem = i.SubItems
                            .Select(si => new global::MinRepro.LinqraftGenerated_15C8F54D.Issue_NestedSelectExprTest.SubItemDto
                            {
                                Id = si.Id,
                                Value = si.Value
                            }),
                        SubItemWithExpr = i.SubItems
                            .Select(si => new global::MinRepro.NestedSubItemDto
                            {
                                Id = si.Id,
                                Value = si.Value
                      ...

</details>



<!-- START COPILOT CODING AGENT SUFFIX -->

- Fixes arika0093/Linqraft#217

<!-- START COPILOT CODING AGENT TIPS -->
---

💬 We'd love your input! Share your thoughts on Copilot coding agent in our [2 minute survey](https://gh.io/copilot-coding-agent-survey).

[coderabbitai]

Important

Review skipped

Bot user detected.

To trigger a single review, invoke the @coderabbitai review command.

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Note

Other AI code review bot(s) detected

CodeRabbit has detected other AI code review bot(s) in this pull request and will avoid duplicating their findings in the review comments. This may lead to a less comprehensive review.

---

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

[arika0093]

@copilot Please fix the review comments.

[arika0093]

@copilot