Add pre-built expression tree caching for IQueryable operations

[Copilot]

Implementation Complete: Pre-built Expression Trees ✅

Summary

Successfully implemented pre-built expression tree caching to improve IQueryable performance by avoiding repeated lambda-to-expression-tree conversion at runtime.

Latest Updates (Per Review Feedback)

• ✅ Fixed indentation in generated code - multi-line lambda expressions now properly indented
• ✅ Removed unnecessary ! null-forgiving operator
• ✅ Fixed to use explicit Expression<> type instead of as operator (C# doesn't allow as with lambdas)
• ✅ Refactored to use direct expression initialization - expressions now initialized at field declaration, eliminating lazy initialization and null checks
• ✅ Updated documentation in /docs/library/global-properties.md with comprehensive usage examples and notes
• ✅ Added note about capture variables - pre-building not applied when capture variables are present
• ✅ Added readonly modifier to static expression fields for immutability
• ✅ Added playground toggle - New checkbox in Settings section for interactive testing

Features Implemented

1. New Configuration Option: LinqraftUsePrebuildExpression (default: false)

   • MSBuild property: <LinqraftUsePrebuildExpression>true</LinqraftUsePrebuildExpression>
   • Playground toggle: Settings → "Pre-build Expression Trees" checkbox
   • Only applies to IQueryable (not IEnumerable)
   • Only works with named/predefined/explicit DTO types (not anonymous types)
   • Not applied when there are capture variables in the lambda expression
   • Fully documented in /docs/library/global-properties.md

2. Expression Tree Caching with Direct Initialization

   • Static readonly fields generated at class level with hash-based unique names
   • Direct initialization at field declaration - no lazy loading or null checks
   • Improves first-access performance by avoiding initialization overhead
   • Example generated code:

   private static readonly Expression<Func<SourceType, ResultType>> _cachedExpression_HASH = s =>
       new ResultType
           {
               Property1 = s.Property1,
               Property2 = s.Property2
           };
   
   // Later in method - no null check needed:
   var converted = matchedQuery.Select(_cachedExpression_HASH);

3. Architecture

   • ExpressionTreeBuilder.GenerateExpressionTreeField(): Generates readonly field with direct initialization
   • SelectExprInfo.GenerateStaticFields(): Virtual method for field generation
   • Clean separation between field declaration and method generation

4. Playground Integration

   • Added toggle checkbox in Settings section for interactive testing
   • Changes reflected in real-time in generated code preview
   • Located with other configuration options for consistency

Performance Benefits

• No runtime construction: Expression trees built once at compile-time
• No lazy initialization overhead: Fields initialized directly at declaration with readonly modifier
• No null checks: Expressions ready to use immediately
• Improved first-access performance: No initialization check on first use
• Immutability: readonly ensures expressions cannot be modified after initialization

Limitations

• Anonymous types excluded: Cannot use pre-built expressions because the result type is compiler-generated and unknown at class-field declaration time
• IEnumerable excluded: Feature only applies to IQueryable operations where expression trees are used
• Captures not supported: Pre-built expressions don't work with closure variables

Testing

✅ All 130 tests passing in Linqraft.Tests

• Regular tests continue to work without pre-built expressions
• Feature can be enabled via MSBuild property or playground toggle

Documentation

Complete documentation added to /docs/library/global-properties.md including:

• Configuration property definition
• Usage examples
• Important notes about limitations
• Performance benefits explanation

Original prompt

---

This section details on the original issue you should resolve

<issue_title>proposal: Pre-build Expression Trees to improve performance</issue_title>
<issue_description>Currently, we are constructing the "as-is" expression tree, but by pre-building and caching it, we can expect performance improvements.
The expected behavior is as follows:

• Pre-build the Expression Tree based on the information in SelectExprInfo
• Avoid runtime construction as much as possible and use statically cached Expression Trees
  • The idea is to cache it as a variable within the generated class. A hash value is added to avoid duplication.
• Add a new option to LinqraftConfiguration (e.g., LinqraftUsePrebuildExpression: bool) which is disabled by default
• Apply only to IQueryable patterns, not to IEnumerable (obviously)
  </issue_description>

Comments on the Issue (you are @copilot in this section)

• Fixes proposal: Pre-build Expression Trees to improve performance #233

---

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.

[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 The indentation of the generated code is inappropriate. Please correct it properly.

[Copilot]

@copilot The indentation of the generated code is inappropriate. Please correct it properly.

Fixed in commit 8d68c20. The generated code now properly indents multi-line lambda expressions. The lambda body is indented at 3 levels (12 spaces) to align with the expected formatting.

[arika0093]

@copilot

[arika0093]

@copilot Please also make changes on the playground side. Add a toggle option to the Settings side and ensure it is reflected in the generated code.

[Copilot]

@copilot Please also make changes on the playground side. Add a toggle option to the Settings side and ensure it is reflected in the generated code.

Added in commit 174eb45. The playground now includes a toggle checkbox in the Settings section labeled "Pre-build Expression Trees" that controls the UsePrebuildExpression configuration option. Changes are reflected in the generated code preview.