Refine LQRF003 to EF Core DbSet only, add LQRF004 for synchronous IQueryable scenarios (#285)

* Initial plan

* Add LQRF004 analyzer and update LQRF003 with DbSet requirement

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

* Add tests for LQRF003 and LQRF004 analyzers

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

* Fix documentation issues in LQRF003 and LQRF004

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

* Fix DbSet detection for chained queries

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: arika0093 <4524647+arika0093@users.noreply.github.com>
Co-authored-by: arika <Delete0093@Gmail.com>

Author: Copilot

docs/analyzer/LQRF003.md docs/analyzers/LQRF003.mddocs/analyzer/LQRF003.md renamed to docs/analyzers/LQRF003.md

@@ -1,8 +1,10 @@
-# LQRF003: Generate API Response Methods
+# LQRF003: Generate Async API Response Methods (EntityFramework)
 
 ## Overview
 
-The LQRF003 analyzer detects void or Task (non-generic) methods that contain unassigned Select operations with anonymous types on IQueryable sources. These methods can be automatically converted to async API response methods that return `Task<List<TDto>>`.
+The LQRF003 analyzer detects void or Task (non-generic) methods that contain unassigned Select operations with anonymous types on **DbSet** sources from **EntityFramework Core**. These methods can be automatically converted to async API response methods that return `Task<List<TDto>>`.
+
+This analyzer is specifically designed for EntityFramework Core scenarios and requires EF Core to be referenced in the project.
 
 ## Diagnostic Information
 
@@ -15,24 +17,26 @@ The LQRF003 analyzer detects void or Task (non-generic) methods that contain una
 
 ## Description
 
-When writing API methods, developers often start by writing "mockup" code with void or Task methods that contain a query but don't return anything. This analyzer identifies such patterns and offers a code fix to convert them into proper async API response methods.
+When writing API methods with EntityFramework Core, developers often start by writing "mockup" code with void or Task methods that contain a query on DbContext/DbSet but don't return anything. This analyzer identifies such patterns and offers a code fix to convert them into proper async API response methods.
 
 ### Triggering Conditions
 
 The analyzer will report a diagnostic when ALL of the following conditions are met:
 
-1. The method has a `void` or `Task` (non-generic) return type
-2. The method contains a `.Select()` call with an anonymous type
-3. The Select is called on an `IQueryable<T>` source (not IEnumerable<T>)
-4. The Select result is **not** assigned to a variable (it's a standalone expression statement)
+1. **EntityFramework Core is available** (the project references Microsoft.EntityFrameworkCore)
+2. The method has a `void` or `Task` (non-generic) return type
+3. The method contains a `.Select()` call with an anonymous type
+4. The Select is called on a **DbSet<T>** (from EntityFramework Core DbContext)
+5. The Select result is **not** assigned to a variable (it's a standalone expression statement)
 
 ### Non-Triggering Conditions
 
 The analyzer will NOT report a diagnostic when:
 
+- EntityFramework Core is not available in the project
+- The Select is called on `IQueryable<T>` that is not a DbSet (e.g., `list.AsQueryable()`)
 - The method returns `Task<T>` (already has a return type)
 - The Select uses a named type instead of an anonymous type
-- The Select is called on `IEnumerable<T>` instead of `IQueryable<T>`
 - The Select result is assigned to a variable
 
 ## Code Fix
@@ -104,35 +108,64 @@ class MyClass
 }
 ```
 
-### Example 2: Task Method
+### Example 2: Task Method with DbContext
 
 **Before:**
 
 ```csharp
-async Task GetItems()  // LQRF003: Method 'GetItems' can be converted to an async API response method
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+
+class MyClass
 {
-    var list = new List<Item>();
-    await list.AsQueryable()
-        .Where(i => i.Id > 0)
-        .Select(i => new { i.Id, i.Name });
+    private readonly MyAppDbContext _dbContext;
+
+    public MyClass(MyAppDbContext dbContext)
+    {
+        _dbContext = dbContext;
+    }
+
+    async Task GetItems()  // LQRF003: Method 'GetItems' can be converted to an async API response method
+    {
+        _dbContext.Items
+            .Where(i => i.Id > 0)
+            .Select(i => new { i.Id, i.Name });
+    }
 }
 ```
 
 **After applying code fix:**
 
 ```csharp
-async Task<List<ItemDto_XXXXXXX>> GetItemsAsync()
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using System.Collections.Generic;
+
+class MyClass
 {
-    var list = new List<Item>();
-    return await list.AsQueryable()
-        .Where(i => i.Id > 0)
-        .SelectExpr<Item, ItemDto_XXXXXXX>(i => new { i.Id, i.Name })
-        .ToListAsync();
+    private readonly MyAppDbContext _dbContext;
+
+    public MyClass(MyAppDbContext dbContext)
+    {
+        _dbContext = dbContext;
+    }
+
+    async Task<List<ItemDto_XXXXXXX>> GetItemsAsync()
+    {
+        return await _dbContext.Items
+            .Where(i => i.Id > 0)
+            .SelectExpr<Item, ItemDto_XXXXXXX>(i => new { i.Id, i.Name })
+            .ToListAsync();
+    }
 }
 ```
 
 ## Notes
 
+- This analyzer **requires EntityFramework Core** to be referenced in the project
+- The Select must be called on a **DbSet<T>** property from a DbContext
 - The generated DTO name follows the same naming conventions as other Linqraft analyzers
 - The code fix automatically adds required using directives:
   - `System.Threading.Tasks`
@@ -144,6 +177,7 @@ async Task<List<ItemDto_XXXXXXX>> GetItemsAsync()
 
 ## Related Analyzers
 
+- **LQRF004**: Convert method to synchronous API response method (non-EF, synchronous version)
 - **LQRS002**: IQueryable.Select can be converted to SelectExpr (anonymous)
 - **LQRS003**: IQueryable.Select can be converted to SelectExpr (named DTO)
 - **LQRF002**: Add ProducesResponseType to clarify API return type

docs/analyzers/LQRF004.md

@@ -0,0 +1,183 @@
+# LQRF004: Generate Synchronous API Response Methods
+
+## Overview
+
+The LQRF004 analyzer detects void methods that contain unassigned Select operations with anonymous types on **IQueryable** sources. These methods can be automatically converted to synchronous API response methods that return `List<TDto>`.
+
+This analyzer is the synchronous version of LQRF003, designed for non-EntityFramework scenarios or when async/await is not needed.
+
+## Diagnostic Information
+
+- **Diagnostic ID**: LQRF004
+- **Title**: Method can be converted to synchronous API response method
+- **Message**: Method '{0}' can be converted to a synchronous API response method
+- **Category**: Design
+- **Severity**: Info
+- **Enabled by Default**: Yes
+
+## Description
+
+When writing API methods, developers often start by writing "mockup" code with void methods that contain a query but don't return anything. This analyzer identifies such patterns and offers a code fix to convert them into proper synchronous API response methods.
+
+### Triggering Conditions
+
+The analyzer will report a diagnostic when ALL of the following conditions are met:
+
+1. The method has a `void` return type (not Task)
+2. The method contains a `.Select()` call with an anonymous type
+3. The Select is called on an `IQueryable<T>` source (not IEnumerable<T>)
+4. The Select result is **not** assigned to a variable (it's a standalone expression statement)
+
+### Non-Triggering Conditions
+
+The analyzer will NOT report a diagnostic when:
+
+- The method returns any type other than void
+- The Select uses a named type instead of an anonymous type
+- The Select is called on `IEnumerable<T>` instead of `IQueryable<T>`
+- The Select result is assigned to a variable
+
+## Code Fix
+
+The code fix performs the following transformations:
+
+1. Changes the return type from `void` to `List<TDto>`
+2. Adds `return` keyword before the query
+3. Replaces `.Select(...)` with `.SelectExpr<TSource, TDto>(...)`
+4. Adds `.ToList()` at the end of the query
+5. Adds necessary using directives
+
+**Note:** Unlike LQRF003, this analyzer does NOT:
+- Add `async` keyword
+- Add `await` keyword
+- Use `ToListAsync()` 
+- Add `Microsoft.EntityFrameworkCore` using directive
+
+## Examples
+
+### Example 1: Void Method with IQueryable
+
+**Before:**
+
+```csharp
+using System.Linq;
+using System.Collections.Generic;
+
+class Item
+{
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public bool IsActive { get; set; }
+}
+
+class MyClass
+{
+    void GetItems()  // LQRF004: Method 'GetItems' can be converted to a synchronous API response method
+    {
+        var list = new List<Item>();
+        list.AsQueryable()
+            .Where(i => i.IsActive)
+            .Select(i => new { i.Id, i.Name });
+    }
+}
+```
+
+**After applying code fix:**
+
+```csharp
+using System.Linq;
+using System.Collections.Generic;
+
+class Item
+{
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public bool IsActive { get; set; }
+}
+
+class MyClass
+{
+    List<ItemsDto_XXXXXXX> GetItems()
+    {
+        var list = new List<Item>();
+        return list.AsQueryable()
+            .Where(i => i.IsActive)
+            .SelectExpr<Item, ItemsDto_XXXXXXX>(i => new { i.Id, i.Name }).ToList();
+    }
+}
+```
+
+### Example 2: Void Method with Chained Operations
+
+**Before:**
+
+```csharp
+using System.Linq;
+using System.Collections.Generic;
+
+class MyClass
+{
+    void GetActiveItems()  // LQRF004: Method 'GetActiveItems' can be converted to a synchronous API response method
+    {
+        var items = new List<Item>();
+        items.AsQueryable()
+            .Where(i => i.Id > 0)
+            .OrderBy(i => i.Name)
+            .Select(i => new { i.Id, i.Name });
+    }
+}
+```
+
+**After applying code fix:**
+
+```csharp
+using System.Linq;
+using System.Collections.Generic;
+
+class MyClass
+{
+    List<ItemDto_XXXXXXX> GetActiveItems()
+    {
+        var items = new List<Item>();
+        return items.AsQueryable()
+            .Where(i => i.Id > 0)
+            .OrderBy(i => i.Name)
+            .SelectExpr<Item, ItemDto_XXXXXXX>(i => new { i.Id, i.Name }).ToList();
+    }
+}
+```
+
+## Notes
+
+- This analyzer works with **any IQueryable** source, not just EntityFramework DbSets
+- The generated DTO name follows the same naming conventions as other Linqraft analyzers
+- The code fix automatically adds required using directives:
+  - `System.Linq`
+  - `System.Collections.Generic`
+- The code fix preserves formatting and indentation from the original code
+- **No async/await** is used, making this suitable for synchronous scenarios
+
+## Comparison with LQRF003
+
+| Feature | LQRF003 (Async) | LQRF004 (Sync) |
+|---------|-----------------|----------------|
+| Return Type | `Task<List<TDto>>` | `List<TDto>` |
+| Async Keyword | ✅ Yes | ❌ No |
+| Await Keyword | ✅ Yes | ❌ No |
+| ToList Method | `ToListAsync()` | `ToList()` |
+| EF Core Required | ✅ Yes | ❌ No |
+| DbSet Required | ✅ Yes | ❌ No |
+| IQueryable Support | DbSet only | Any IQueryable |
+| Suitable For | EF Core async operations | Synchronous operations |
+
+## Related Analyzers
+
+- **LQRF003**: Convert method to async API response method (EntityFramework, async version)
+- **LQRS002**: IQueryable.Select can be converted to SelectExpr (anonymous)
+- **LQRS003**: IQueryable.Select can be converted to SelectExpr (named DTO)
+- **LQRF002**: Add ProducesResponseType to clarify API return type
+
+## See Also
+
+- [SelectExpr Usage Patterns](../library/usage-patterns.md)
+- [Auto-Generated DTOs](../library/auto-generated-comments.md)

docs/analyzers/README.md

@@ -5,6 +5,8 @@
 |---------------|----------|-------------|-------|---------|
 | [LQRF001](./LQRF001.md) | AnonymousTypeToDtoAnalyzer | Suggest converting anonymous types to DTO classes | Hidden | ✅️ |
 | [LQRF002](./LQRF002.md) | ApiControllerProducesResponseTypeAnalyzer | Suggest adding `ProducesResponseType` for untyped API actions using `SelectExpr` | Info | ✅️ |
+| [LQRF003](./LQRF003.md) | ApiResponseMethodGeneratorAnalyzer | Convert void/Task method with DbSet Select to async API response method | Info | ✅️ |
+| [LQRF004](./LQRF004.md) | SyncApiResponseMethodGeneratorAnalyzer | Convert void method with IQueryable Select to synchronous API response method | Info | ✅️ |
 | [LQRS001](./LQRS001.md) | SelectExprToTypedAnalyzer | Suggest converting untyped `SelectExpr` to generic form `SelectExpr<TSource, TDto>` | Hidden | ✅️ |
 | [LQRS002](./LQRS002.md) | SelectToSelectExprAnonymousAnalyzer | `IQueryable.Select` with anonymous projection → `SelectExpr` suggestion | Info | ✅️ |
 | [LQRS003](./LQRS003.md) | SelectToSelectExprNamedAnalyzer | `IQueryable.Select` with named-object projection → `SelectExpr` suggestion | Info | ✅️ |