Revert "Integrate LQRS004 ternary null check transformation into LQRS002/LQRS003 (#171)"

This reverts commit f551f00.

(cherry picked from commit a0d1a02)

Author: arika0093

docs/analyzers/LQRS002.md

@@ -22,21 +22,6 @@ Detects `System.Linq` `Select` calls performed on `IQueryable<T>` whose selector
 - Convert `Select(...)` → `SelectExpr(...)` preserving the anonymous projection.
 - Convert `Select(...)` → `SelectExpr<TSource, TDto>(...)` with a generated DTO type when that is preferable.
 
-### Automatic Ternary Null Check Simplification
-As of version 0.5.0, the code fix also **automatically simplifies ternary null check patterns** (previously handled by LQRS004). When converting `Select` to `SelectExpr`, patterns like:
-
-```csharp
-prop = x.A != null ? new { x.A.B } : null
-```
-
-are automatically converted to:
-
-```csharp
-prop = new { B = x.A?.B }
-```
-
-This provides more concise code using null-conditional operators. See [LQRS004](LQRS004.md) for details on this transformation.
-
 ## Example
 Before:
 ```csharp
@@ -67,20 +52,3 @@ var result = query.SelectExpr<Product, ResultDto_XXXXXXXX>(x => new
     x.Price
 });
 ```
-
-### With Ternary Null Check Simplification
-Before:
-```csharp
-var result = query.Select(x => new
-{
-    ChildData = x.Child != null ? new { x.Child.Name } : null
-});
-```
-
-After (with automatic simplification):
-```csharp
-var result = query.SelectExpr(x => new
-{
-    ChildData = new { Name = x.Child?.Name }
-});
-```

docs/analyzers/LQRS003.md

@@ -20,36 +20,21 @@ Detects `System.Linq` `Select` invocations on `IQueryable<T>` whose selector cre
 ## Code Fixes
 `SelectToSelectExprNamedCodeFixProvider` registers three distinct fixes (titles shown are from the provider):
 
-- **Convert to SelectExpr<T, TDto>**
-  - Converts the `Select` method to a generic `SelectExpr<TSource, TDto>` and **converts the named object creation into an anonymous object**. This variant recursively converts nested object creations as well (deep conversion). It also runs the ternary-null simplifier on the generated anonymous structures, converting patterns like `x.A != null ? x.A.B : null` to `x.A?.B`.
+- **Convert to SelectExpr<T, TDto> (convert all to anonymous)**
+  - Converts the `Select` method to a generic `SelectExpr<TSource, TDto>` and **converts the named object creation into an anonymous object**. This variant recursively converts nested object creations as well (deep conversion). It also runs the ternary-null simplifier on the generated anonymous structures.
 
-- **Convert to SelectExpr<T, TDto> (strict)**
-  - Similar to the above, but **does NOT apply ternary null check simplification**. This preserves the original ternary patterns (e.g., `x.A != null ? x.A.B : null` remains unchanged). Useful when you want to maintain the exact nullability structure of the original code. You can apply [LQRS004](LQRS004.md) manually afterward if needed.
+- **Convert to SelectExpr<T, TDto> (convert root only to anonymous)**
+  - Similar to the above, but converts only the reported (root) object creation to an anonymous object; nested object creations are left as-is. Produces a generic `SelectExpr<TSource, TDto>` and applies the ternary-null simplifier to the root anonymous creation.
 
 - **Convert to SelectExpr (use predefined classes)**
-  - Replaces the method name `Select` with `SelectExpr` (no generic type arguments) and preserves the existing named DTO type in the selector. This variant **does NOT apply ternary null check simplification**, preserving the original ternary patterns. You can apply [LQRS004](LQRS004.md) manually afterward if needed.
+  - Replaces the method name `Select` with `SelectExpr` (no generic type arguments) and preserves the existing named DTO type in the selector. This variant also simplifies ternary-null checks inside the selector lambda but does not convert named object creation into anonymous objects.
 
-### Automatic Ternary Null Check Simplification
-The first code fix option **automatically simplifies ternary null check patterns**. When converting `Select` to `SelectExpr`, patterns like:
-
-```csharp
-prop = x.A != null ? x.A.B : null
-```
-
-are automatically converted to:
-
-```csharp
-prop = x.A?.B
-```
-
-This provides more concise code using null-conditional operators. The second option (strict) and third option (predefined) intentionally preserve the original ternary patterns. You can use [LQRS004](LQRS004.md) to manually apply the transformation afterward.
-
-These three options map directly to the code-fix implementations: `ConvertToSelectExprExplicitDtoAsync`, `ConvertToSelectExprExplicitDtoStructAsync`, and `ConvertToSelectExprPredefinedDtoAsync`.
+These three options map directly to the code-fix implementations: `ConvertToSelectExprExplicitDtoAllAsync`, `ConvertToSelectExprExplicitDtoRootOnlyAsync`, and `ConvertToSelectExprPredefinedDtoAsync`.
 
 ## Examples
 The examples below show the concrete transformations performed by each fix.
 
-1) Convert to `SelectExpr<T, TDto>` (with ternary simplification)
+1) Convert to `SelectExpr<T, TDto>` (all)
 
 Before:
 ```csharp
@@ -59,30 +44,29 @@ var result = query
     {
         Id = x.Id,
         Name = x.Name,
-        DetailDesc = x.Detail != null ? x.Detail.Desc : null
+        Details = new ProductDetailDto { Desc = x.Detail.Desc }
     })
-    .ToList();
+    .Select(p => new WrapperDto { Item = p });
 ```
 
-After:
+After (all fix):
 ```csharp
 var result = query
     .SelectMany(g => g.Items)
     .SelectExpr<Product, ResultDto_HASH>(x => new // root converted to anonymous
     {
         Id = x.Id,
         Name = x.Name,
-        DetailDesc = x.Detail?.Desc // ternary simplified to null-conditional
+        Details = new { Desc = x.Detail.Desc } // nested also converted to anonymous
     })
-    .ToList();
+    .SelectExpr(p => new WrapperDto { Item = p });
 ```
 
 Notes:
-- The named `ProductDto` initializer is converted to an anonymous initializer.
-- Ternary null check patterns are simplified to null-conditional operators.
-- A DTO name (e.g. `ResultDto_HASH`) is generated for the generic type argument.
+- Both the root `ProductDto` and the nested `ProductDetailDto` are converted to anonymous initializers (deep conversion).
+- The fixer inserts generic type arguments on the `SelectExpr` call using a generated DTO name.
 
-2) Convert to `SelectExpr<T, TDto>` (struct - no ternary simplification)
+2) Convert to `SelectExpr<T, TDto>` (root-only)
 
 Before:
 ```csharp
@@ -92,28 +76,27 @@ var result = query
     {
         Id = x.Id,
         Name = x.Name,
-        DetailDesc = x.Detail != null ? x.Detail.Desc : null
+        Details = new ProductDetailDto { Desc = x.Detail.Desc }
     })
     .ToList();
 ```
 
-After (struct fix):
+After (root-only fix):
 ```csharp
 var result = query
     .Where(p => p.IsActive)
     .SelectExpr<Product, ResultDto_HASH>(x => new // root converted to anonymous
     {
         Id = x.Id,
         Name = x.Name,
-        DetailDesc = x.Detail != null ? x.Detail.Desc : null // ternary preserved
+        Details = new ProductDetailDto { Desc = x.Detail.Desc } // nested remains named
     })
     .ToList();
 ```
 
 Notes:
-- The named `ProductDto` initializer is converted to an anonymous initializer.
-- Ternary null check patterns are **preserved** - no simplification is applied.
-- Use this option when you need to maintain the exact nullability structure.
+- The named `ProductDto` initializer is converted to an anonymous initializer at the root only.
+- A DTO name (e.g. `ResultDto_HASH`) is generated for the generic type argument; the code-fix inserts type arguments but replaces the selector body with an anonymous object.
 
 3) Convert to `SelectExpr` (predefined)
 
@@ -124,7 +107,7 @@ var result = query.Select(x => new ProductDto
 {
     Id = x.Id,
     Name = x.Name,
-    DetailDesc = x.Detail != null ? x.Detail.Desc : null
+    Details = new ProductDetailDto { Desc = x.Detail.Desc }
 });
 ```
 
@@ -134,11 +117,10 @@ var result = query.SelectExpr(x => new ProductDto // named DTO preserved
 {
     Id = x.Id,
     Name = x.Name,
-    DetailDesc = x.Detail != null ? x.Detail.Desc : null // ternary preserved
+    Details = new ProductDetailDto { Desc = x.Detail.Desc }
 });
 ```
 
 Notes:
 - This variant preserves the named DTO (`ProductDto`) and only changes the method to `SelectExpr`.
-- Ternary null check patterns are **preserved** - no simplification is applied.
-- You can apply [LQRS004](LQRS004.md) manually afterward if you want the simplified form.
+- Ternary-null simplifications inside the lambda are still applied where the simplifier can transform patterns safely.

docs/analyzers/LQRS004.md

@@ -5,33 +5,21 @@
 **Default:** Enabled
 
 ## Description
-Detects conditional (ternary) expressions where one branch returns `null` (or a nullable null-cast) and the other branch returns an object creation (anonymous or named), and the condition contains a null-check expression. Such patterns are often simplifiable using null-conditional (`?.`) chains or other null-safe idioms.
+Detects conditional (ternary) expressions where one branch returns `null` (or a nullable null-cast) and the other branch returns an object creation (anonymous or named), and the condition contains a null-check expression. Such patterns are often simplifyable using null-conditional (`?.`) chains or other null-safe idioms.
 
 ## When It Triggers
 - The node is a conditional expression (`condition ? whenTrue : whenFalse`).
 - The condition contains a null check (e.g. `x != null`, `x == null`) or a logical-and chain that includes a null check.
 - One branch is `null` (or `(Type?)null`) and the other branch constructs an object (`new ...` or anonymous `new { ... }`).
-- The conditional is inside a `SelectExpr` call.
 
 ## When It Doesn't Trigger
 - Neither branch is an object creation.
 - The condition doesn't include a null-check.
-- The conditional is outside a `SelectExpr` call.
 
 ## Suggested Transformation
 The analyzer reports an informational diagnostic and suggests a null-propagation style replacement when the pattern is a simple null check that guards an object creation. A common safe transformation is to move the nullable operator into the member access so that inner member accesses use the null-conditional operator.
 
-### Relationship with LQRS002/LQRS003
-
-Some `Select` → `SelectExpr` conversion options automatically apply this transformation:
-- **LQRS002** (anonymous type): Always applies ternary simplification
-- **LQRS003 "Explicit"**: Applies ternary simplification
-
-Others preserve the original ternary patterns:
-- **LQRS003 "Explicit (strict)"**: Does NOT apply ternary simplification
-- **LQRS003 "Predefined"**: Does NOT apply ternary simplification
-
-For the conversions that preserve ternary patterns, you can use LQRS004 to manually apply the transformation afterward if desired.
+Because this transformation changes the position of nullability (e.g. from the selector producing `null` to the individual property access becoming nullable), it is handled separately from the `Select` → `SelectExpr` conversions (`LQRS002`/`LQRS003`). The `SelectExpr` conversions intentionally do not perform this rewrite automatically because moving the nullable operator may change semantics in subtle ways.
 
 ### Replacement example
 Given a conditional like:
@@ -43,4 +31,4 @@ the analyzer suggests replacing the object-creating ternary with a projection th
 new { B = x.A?.B }
 ```
 
-This effectively collapses the ternary and moves the `?.` into the member access, producing an object whose properties are null when the source is null instead of returning `null` for the whole object. Because the resulting nullability shape differs from the original expression, this transformation is offered as an informational suggestion.
+This effectively collapses the ternary and moves the `?.` into the member access, producing an object whose properties are null when the source is null instead of returning `null` for the whole object. Because the resulting nullability shape differs from the original expression, the analyzer treats this as a separate informational suggestion rather than part of `Select`→`SelectExpr` automated conversions.

src/Linqraft.Analyzer/SelectToSelectExprNamedCodeFixProvider.cs

@@ -50,20 +50,20 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
         // Register three code fixes
         context.RegisterCodeFix(
             CodeAction.Create(
-                title: "Convert to SelectExpr<T, TDto>",
+                title: "Convert to SelectExpr<T, TDto> (convert all to anonymous)",
                 createChangedDocument: c =>
-                    ConvertToSelectExprExplicitDtoAsync(context.Document, invocation, c),
-                equivalenceKey: "ConvertToSelectExprExplicitDto"
+                    ConvertToSelectExprExplicitDtoAllAsync(context.Document, invocation, c),
+                equivalenceKey: "ConvertToSelectExprExplicitDtoAll"
             ),
             diagnostic
         );
 
         context.RegisterCodeFix(
             CodeAction.Create(
-                title: "Convert to SelectExpr<T, TDto> (strict)",
+                title: "Convert to SelectExpr<T, TDto> (convert root only to anonymous)",
                 createChangedDocument: c =>
-                    ConvertToSelectExprExplicitDtoStructAsync(context.Document, invocation, c),
-                equivalenceKey: "ConvertToSelectExprExplicitDtoStruct"
+                    ConvertToSelectExprExplicitDtoRootOnlyAsync(context.Document, invocation, c),
+                equivalenceKey: "ConvertToSelectExprExplicitDtoRootOnly"
             ),
             diagnostic
         );
@@ -79,7 +79,7 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
         );
     }
 
-    private static async Task<Document> ConvertToSelectExprExplicitDtoAsync(
+    private static async Task<Document> ConvertToSelectExprExplicitDtoAllAsync(
         Document document,
         InvocationExpressionSyntax invocation,
         CancellationToken cancellationToken
@@ -164,11 +164,7 @@ CancellationToken cancellationToken
             .ConfigureAwait(false);
     }
 
-    /// <summary>
-    /// Converts to SelectExpr with explicit DTO but WITHOUT ternary null check simplification.
-    /// This maintains the traditional struct-like behavior where ternary patterns are preserved.
-    /// </summary>
-    private static async Task<Document> ConvertToSelectExprExplicitDtoStructAsync(
+    private static async Task<Document> ConvertToSelectExprExplicitDtoRootOnlyAsync(
         Document document,
         InvocationExpressionSyntax invocation,
         CancellationToken cancellationToken
@@ -209,9 +205,12 @@ CancellationToken cancellationToken
         if (newExpression == null)
             return document;
 
-        // Convert the named object creation to anonymous type (including nested)
-        // NOTE: No ternary simplification is applied here - this preserves the original structure
-        var anonymousCreation = ConvertToAnonymousTypeRecursive(objectCreation);
+        // Convert the named object creation to anonymous type (root only)
+        var anonymousCreation = ConvertToAnonymousType(objectCreation, semanticModel);
+
+        // Simplify ternary null checks in the anonymous creation
+        anonymousCreation = (AnonymousObjectCreationExpressionSyntax)
+            TernaryNullCheckSimplifier.SimplifyTernaryNullChecks(anonymousCreation);
 
         // Replace both nodes in one operation using a dictionary
         var replacements = new Dictionary<SyntaxNode, SyntaxNode>
@@ -274,9 +273,10 @@ CancellationToken cancellationToken
         if (newExpression == null)
             return document;
 
-        // For Predefined pattern, we do NOT simplify ternary null checks
-        // Users can manually apply LQRS004 afterward if they want the simplified form
-        var newInvocation = invocation.WithExpression(newExpression);
+        // Simplify ternary null checks in the lambda body
+        var newInvocation = TernaryNullCheckSimplifier.SimplifyTernaryNullChecksInInvocation(
+            invocation.WithExpression(newExpression)
+        );
 
         // Add capture parameter if needed
         if (variablesToCapture.Count > 0)