Fix DisplayExpressionTransform to emit idiomatic @expr for simple expressions

Simple dotted identifiers (Item.ProductName) now emit @Item.ProductName
Complex expressions (method calls, operators) still emit @(expr)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: csharpfritz

.squad/agents/bishop/history.md

@@ -132,3 +132,9 @@
 - Extended `ServerShim` with `Transfer`, `GetLastError`, and `ClearError`, and updated `ServerShimTransform` guidance to treat those APIs as supported compatibility shims instead of dead-end TODOs.
 - Added focused regression tests for the new transforms, source-file copying, and ServerShim behavior; updated CLI docs plus migration docs so HttpUtility guidance now points to inline `WebUtility` rewrites rather than relying on the legacy shim package.
 - Validation: `dotnet build src\BlazorWebFormsComponents\BlazorWebFormsComponents.csproj --nologo`, `dotnet test src\BlazorWebFormsComponents.Test --nologo`, and `dotnet test tests\BlazorWebFormsComponents.Cli.Tests --nologo`.
+
+### 2026-05-06T21:33:09-04:00: DisplayExpressionTransform emits idiomatic Razor for simple expressions (Bishop)
+- DisplayExpressionTransform now classifies dotted identifier chains with a dedicated regex helper and emits @expr for simple display expressions while preserving @(expr) for method calls, operators, and other complex expressions.
+- Updated focused coverage in tests\\BlazorWebFormsComponents.Cli.Tests\\TransformUnit\\DisplayExpressionTransformTests.cs for simple and complex cases, plus pipeline assertions for both shapes.
+- Updated L1 expected fixtures TC06-Expressions.razor and TC30-DataDrivenPage.razor to reflect idiomatic Razor output in generated markup.
+- Validation: dotnet test tests\\BlazorWebFormsComponents.Cli.Tests --nologo --filter DisplayExpression (9 passing) and dotnet test tests\\BlazorWebFormsComponents.Cli.Tests --nologo (573 passing).

.squad/decisions/inbox/bishop-display-expr-fix.md

@@ -0,0 +1,33 @@
+# Decision: DisplayExpressionTransform emits idiomatic Razor for simple expressions
+
+**Date:** 2026-05-06
+**Author:** Bishop (Migration Tooling Dev)
+**Status:** Implemented
+
+## Decision
+
+Update `DisplayExpressionTransform` so simple dotted identifier display expressions emit bare Razor `@expr`, while complex expressions continue to emit `@(expr)`.
+
+## Scope
+
+- Simple expressions match identifier chains such as `Item.ProductName`, `Item.UnitPrice`, `Model.Title`, and `user.Email`.
+- Complex expressions keep parentheses, including method calls, operators, ternaries, indexers, and casts.
+- Broken generated `@(: expr)` output is normalized through the same formatter so simple cases become idiomatic Razor too.
+
+## Rationale
+
+The old transform emitted `@(expr)` for every display expression. That output compiled, but it produced noisy, non-idiomatic Razor for the most common migrated shape: property access on the current item or model.
+
+Using bare `@expr` for simple member chains keeps generated Razor closer to what a Blazor developer would naturally write, without sacrificing correctness for complex expressions that still require grouping.
+
+## Files Updated
+
+- `src\BlazorWebFormsComponents.Cli\Transforms\Markup\DisplayExpressionTransform.cs`
+- `tests\BlazorWebFormsComponents.Cli.Tests\TransformUnit\DisplayExpressionTransformTests.cs`
+- `tests\BlazorWebFormsComponents.Cli.Tests\TestData\expected\TC06-Expressions.razor`
+- `tests\BlazorWebFormsComponents.Cli.Tests\TestData\expected\TC30-DataDrivenPage.razor`
+
+## Validation
+
+- `dotnet test tests\BlazorWebFormsComponents.Cli.Tests --nologo --filter "DisplayExpression"`
+- `dotnet test tests\BlazorWebFormsComponents.Cli.Tests --nologo`

src/BlazorWebFormsComponents.Cli/Transforms/Markup/DisplayExpressionTransform.cs

@@ -6,7 +6,7 @@ namespace BlazorWebFormsComponents.Cli.Transforms.Markup;
 /// <summary>
 /// Normalizes Web Forms display expressions before broader expression handling.
 /// Converts HTML-encoded display blocks and broken generated Razor output into
-/// standard Razor <c>@(...)</c> expressions.
+/// idiomatic Razor expressions.
 /// </summary>
 public class DisplayExpressionTransform : IMarkupTransform
 {
@@ -22,14 +22,29 @@ public class DisplayExpressionTransform : IMarkupTransform
         @"@\(\s*:\s*(.*?)\s*\)",
         RegexOptions.Compiled | RegexOptions.Singleline);
 
+    private static readonly Regex SimpleExpressionRegex = new(
+        @"^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$",
+        RegexOptions.Compiled);
+
     public string Name => "DisplayExpression";
     public int Order => 490;
 
     public string Apply(string content, FileMetadata metadata)
     {
-        content = DisplayExpressionRegex.Replace(content, match => $"@({match.Groups[1].Value.Trim()})");
-        content = ColonEqualsExpressionRegex.Replace(content, match => $"@({match.Groups[1].Value.Trim()})");
-        content = BrokenRazorDisplayRegex.Replace(content, match => $"@({match.Groups[1].Value.Trim()})");
+        content = DisplayExpressionRegex.Replace(content, match => FormatExpression(match.Groups[1].Value));
+        content = ColonEqualsExpressionRegex.Replace(content, match => FormatExpression(match.Groups[1].Value));
+        content = BrokenRazorDisplayRegex.Replace(content, match => FormatExpression(match.Groups[1].Value));
         return content;
     }
+
+    private static string FormatExpression(string expression)
+    {
+        var expr = expression.Trim();
+        return IsSimpleExpression(expr) ? "@" + expr : "@(" + expr + ")";
+    }
+
+    private static bool IsSimpleExpression(string expr)
+    {
+        return SimpleExpressionRegex.IsMatch(expr);
+    }
 }

tests/BlazorWebFormsComponents.Cli.Tests/TestData/expected/TC06-Expressions.razor

@@ -1,6 +1,6 @@
 @page "/TC06-Expressions"
 <PageTitle>Test</PageTitle>
 <span>@context.Name</span>
-<span>@(Item.Price)</span>
+<span>@Item.Price</span>
 <span>@(DateTime.Now)</span>
 <span>@(someVar)</span>

tests/BlazorWebFormsComponents.Cli.Tests/TestData/expected/TC30-DataDrivenPage.razor

@@ -23,7 +23,7 @@
         <ItemTemplate>
             <div class="product-card">
                 <h4>@context.ProductName</h4>
-                <span class="price">@(Item.UnitPrice)</span>
+                <span class="price">@Item.UnitPrice</span>
             </div>
         </ItemTemplate>
     </Repeater>

tests/BlazorWebFormsComponents.Cli.Tests/TransformUnit/DisplayExpressionTransformTests.cs

@@ -23,27 +23,43 @@ public void HasExpectedMetadata()
     }
 
     [Fact]
-    public void ConvertsEncodedDisplayExpression()
+    public void ConvertsEncodedDisplayExpressionToIdiomaticRazorForSimpleExpression()
     {
         var result = _transform.Apply("<span><%#: Item.Name %></span>", TestMetadata);
 
-        Assert.Equal("<span>@(Item.Name)</span>", result);
+        Assert.Equal("<span>@Item.Name</span>", result);
     }
 
     [Fact]
-    public void ConvertsColonEqualsDisplayExpression()
+    public void ConvertsColonEqualsDisplayExpressionToIdiomaticRazorForSimpleExpression()
     {
         var result = _transform.Apply("<span><%=: someVar %></span>", TestMetadata);
 
-        Assert.Equal("<span>@(someVar)</span>", result);
+        Assert.Equal("<span>@someVar</span>", result);
     }
 
     [Fact]
-    public void FixesBrokenGeneratedRazorDisplayExpression()
+    public void KeepsParenthesesForMethodCallExpression()
+    {
+        var result = _transform.Apply("<span><%#: item.GetPrice() %></span>", TestMetadata);
+
+        Assert.Equal("<span>@(item.GetPrice())</span>", result);
+    }
+
+    [Fact]
+    public void KeepsParenthesesForOperatorExpression()
+    {
+        var result = _transform.Apply("<span><%#: Item.UnitPrice + tax %></span>", TestMetadata);
+
+        Assert.Equal("<span>@(Item.UnitPrice + tax)</span>", result);
+    }
+
+    [Fact]
+    public void FixesBrokenGeneratedRazorDisplayExpressionToIdiomaticRazorForSimpleExpression()
     {
         var result = _transform.Apply("<span>@(: expr)</span>", TestMetadata);
 
-        Assert.Equal("<span>@(expr)</span>", result);
+        Assert.Equal("<span>@expr</span>", result);
     }
 
     [Fact]
@@ -68,6 +84,23 @@ public void PipelinePreservesNormalizedDisplayExpression()
 
         var result = pipeline.TransformMarkup("<ItemTemplate><%#: Item.Name %></ItemTemplate>", metadata);
 
-        Assert.Contains("@(Item.Name)", result);
+        Assert.Contains("@Item.Name", result);
+    }
+
+    [Fact]
+    public void PipelinePreservesParenthesesForComplexDisplayExpression()
+    {
+        var pipeline = TestHelpers.CreateDefaultPipeline();
+        var metadata = new FileMetadata
+        {
+            SourceFilePath = "Product.aspx",
+            OutputFilePath = "Product.razor",
+            FileType = FileType.Page,
+            OriginalContent = string.Empty
+        };
+
+        var result = pipeline.TransformMarkup("<ItemTemplate><%#: item.GetPrice() %></ItemTemplate>", metadata);
+
+        Assert.Contains("@(item.GetPrice())", result);
     }
 }