Fix BWFC data control template emission for ListView, FormView, GridView

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

Author: csharpfritz

.squad/agents/bishop/history.md

@@ -35,3 +35,7 @@
 - Deprecate PowerShell scripts — CLI is canonical (2026-05-06T09:16)
 - Audit ALL BWFC Width/Height attributes for string support (2026-05-06T15:12)
 - NEVER replace ListView/FormView/GridView — must use BWFC components (2026-05-07T09:24)
+
+## Learnings
+- **2026-05-07T13:17:32-04:00:** ListView `GroupTemplate` and `LayoutTemplate` emission is more reliable when the CLI emits explicit `Context` names (`items`, `groups`) instead of leaving raw `@context` placeholders. That keeps generated placeholder markup readable and removes one common manual repair step on Wingtip fixtures.
+- **2026-05-07T13:17:32-04:00:** Typed `GridView` columns must inherit the parent grid `ItemType`; leaving `TemplateField` at `ItemType="object"` breaks migrated template expressions like `@Item.Quantity`. A dedicated post-attribute-strip pass that rewrites child BWFC column generics to the grid row type fixes this deterministically.

.squad/decisions/inbox/bishop-template-emission-fix.md

@@ -0,0 +1,27 @@
+# Bishop decision — fix BWFC data-control template emission
+
+**Date:** 2026-05-07T13:17:32-04:00  
+**By:** Bishop  
+**Requested by:** Jeffrey T. Fritz
+
+## Decision
+Add a dedicated CLI markup transform to propagate typed `GridView ItemType` values down into child BWFC column components, and extend template-context normalization so `ListView` group/layout placeholders emit explicit fragment contexts.
+
+## What changed
+1. Added `GridViewColumnItemTypeTransform` at Order 705 after `AttributeStripTransform`.
+2. Rewrote typed `GridView` child `BoundField`, `TemplateField`, `HyperLinkField`, and `ButtonField` tags from `ItemType="object"` to the parent grid item type.
+3. Extended `TemplateContextTransform` so `GroupTemplate` emits `Context="items"` and `LayoutTemplate` emits `Context="groups"` when no explicit context exists.
+4. Added CLI tests covering Wingtip-style `ShoppingCart` and `ProductList` emission.
+5. Updated CLI docs to document the new transform behavior.
+
+## Why
+Run 40 showed Layer 1 output still needed manual structural cleanup on flagship BWFC data controls. The worst failure mode was typed `GridView` templates compiling against `object`, which makes generated expressions like `@Item.Quantity` invalid. Explicit ListView placeholder contexts also make the generated template structure trustworthy and easier to inspect.
+
+## Validation
+- `dotnet test tests\BlazorWebFormsComponents.Cli.Tests --nologo`
+- `dotnet run --project src\BlazorWebFormsComponents.Cli -- convert -i samples\WingtipToys\WingtipToys\ProductList.aspx -o .\bishop-output --overwrite`
+- `dotnet run --project src\BlazorWebFormsComponents.Cli -- convert -i samples\WingtipToys\WingtipToys\ProductDetails.aspx -o .\bishop-output --overwrite`
+- `dotnet run --project src\BlazorWebFormsComponents.Cli -- convert -i samples\WingtipToys\WingtipToys\ShoppingCart.aspx -o .\bishop-output --overwrite`
+
+## Consequences
+Layer 1 now emits cleaner BWFC ListView placeholders and correctly typed GridView columns for Wingtip-style pages, reducing manual repair on the benchmark path. FormView item templates continue to emit valid typed fragments, and the CLI suite now guards this contract.

docs/cli/index.md

@@ -117,7 +117,7 @@ webforms-to-blazor convert \
 The tool applies an ordered transform pipeline and then a semantic pattern catalog:
 
 1. **Directives** (5) — Page, Master, Control, Register, Import directives
-2. **Markup** (20) — Controls, expressions, master-page script cleanup, display-expression cleanup, templates, validator typing, data binding
+2. **Markup** (21) — Controls, expressions, master-page script cleanup, display-expression cleanup, templates, validator typing, typed GridView columns, data binding
 3. **Code-Behind** (26) — Using statements, HttpUtility/EF modernization, base classes, lifecycle, event handlers, compile-surface stubs, markup-driven safety stubs
 
 See **[Transform Reference](transforms.md)** for the flat transform list and **[Semantic Pattern Catalog](semantic-pattern-catalog.md)** for the bounded semantic pass that runs afterward.

docs/cli/transforms.md

@@ -27,11 +27,12 @@ This page documents the flat markup and code-behind transforms applied by the `w
 | 615 | ValidatorGenericTypeTransform | Markup | Markup | Add explicit `Type="string"` / `InputType="string"` defaults for generic BWFC validators |
 | 620 | TemplateFieldChildComponentsTransform | Markup | Markup | Wrap TemplateField style children in `<ChildComponents>` |
 | 700 | AttributeStripTransform | Markup | Markup | Remove `runat="server"`, preserve BWFC `ItemType`, add generic fallbacks |
+| 705 | GridViewColumnItemTypeTransform | Markup | Markup | Propagate typed `GridView ItemType` values to `BoundField` / `TemplateField` child columns |
 | 710 | EventWiringTransform | Markup | Markup | Convert `OnClick="X"` → `OnClick="@X"` |
 | 720 | UrlReferenceTransform | Markup | Markup | Convert `~/` paths to `/` |
 | 750 | ComponentRefMarkupTransform | Markup | Markup | Convert control IDs to `@ref`-compatible component references |
 | 800 | TemplatePlaceholderTransform | Markup | Markup | Replace template placeholder elements with the layout/group render fragment context |
-| 805 | TemplateContextTransform | Markup | Markup | Add `Context="Item"` to typed item templates and rewrite `@context` → `@Item` |
+| 805 | TemplateContextTransform | Markup | Markup | Add explicit item/group/layout template contexts for typed data-control fragments |
 | 810 | AttributeNormalizeTransform | Markup | Markup | Normalize attribute values (booleans, enums, units) |
 | 820 | DataSourceIdTransform | Markup | Markup | Replace DataSourceID with Items binding |
 | 30 | GetRouteUrlTransform | Code-Behind | Code-Behind | Flag `Page.GetRouteUrl()` calls |
@@ -462,6 +463,41 @@ Also:
 
 ---
 
+### 15a. GridViewColumnItemTypeTransform (Order: 705)
+
+**Propagates a typed `GridView` item type down into child BWFC column components.**
+
+When a migrated `GridView` is strongly typed, `TemplateField`, `BoundField`, `HyperLinkField`, and `ButtonField` children must compile against that same row type. This transform rewrites `ItemType="object"` fallbacks on those column tags to the parent grid's concrete `ItemType`, while leaving object-typed grids alone.
+
+**Example:**
+```html
+<!-- Before -->
+<GridView ItemType="CartItem" AutoGenerateColumns="false">
+  <Columns>
+    <BoundField ItemType="object" DataField="ProductID" />
+    <TemplateField ItemType="object" HeaderText="Quantity">
+      <ItemTemplate Context="Item">
+        <TextBox Text="@Item.Quantity" />
+      </ItemTemplate>
+    </TemplateField>
+  </Columns>
+</GridView>
+
+<!-- After -->
+<GridView ItemType="CartItem" AutoGenerateColumns="false">
+  <Columns>
+    <BoundField ItemType="CartItem" DataField="ProductID" />
+    <TemplateField ItemType="CartItem" HeaderText="Quantity">
+      <ItemTemplate Context="Item">
+        <TextBox Text="@Item.Quantity" />
+      </ItemTemplate>
+    </TemplateField>
+  </Columns>
+</GridView>
+```
+
+---
+
 ### 16. EventWiringTransform (Order: 710)
 
 **Converts Web Forms event handler syntax to Blazor.**
@@ -539,21 +575,27 @@ This transform targets placeholder tags such as `itemPlaceholder`, `groupPlaceho
 
 ### 19. TemplateContextTransform (Order: 805)
 
-**Adds `Context="Item"` to typed item templates and rewrites generated `@context` references to `@Item`.**
+**Adds explicit contexts for typed item templates plus named placeholder contexts for `ListView` group/layout fragments.**
 
-This keeps BWFC data controls aligned with Web Forms naming so generated `<ListView>`, `<FormView>`, `<GridView>`, `<DataList>`, and `<Repeater>` templates stay on the component model instead of being flattened into manual HTML.
+This keeps BWFC data controls aligned with Web Forms naming so generated `<ListView>`, `<FormView>`, `<GridView>`, `<DataList>`, and `<Repeater>` templates stay on the component model instead of being flattened into manual HTML. It also upgrades placeholder-only `GroupTemplate` / `LayoutTemplate` blocks to named contexts such as `items` and `groups`, which makes emitted `ListView` markup structurally valid and easier to read.
 
 **Example:**
 ```html
 <!-- Before -->
 <ItemTemplate>
   <TextBox Text="@context.Name" />
 </ItemTemplate>
+<GroupTemplate>
+  <tr>@context</tr>
+</GroupTemplate>
 
 <!-- After -->
 <ItemTemplate Context="Item">
   <TextBox Text="@Item.Name" />
 </ItemTemplate>
+<GroupTemplate Context="items">
+  <tr>@items</tr>
+</GroupTemplate>
 ```
 
 ---

src/BlazorWebFormsComponents.Cli/Program.cs

@@ -60,6 +60,7 @@ private static ServiceProvider BuildServiceProvider()
         services.AddSingleton<IMarkupTransform, ValidatorGenericTypeTransform>();
         services.AddSingleton<IMarkupTransform, TemplateFieldChildComponentsTransform>();
         services.AddSingleton<IMarkupTransform, AttributeStripTransform>();
+        services.AddSingleton<IMarkupTransform, GridViewColumnItemTypeTransform>();
         services.AddSingleton<IMarkupTransform, EventWiringTransform>();
         services.AddSingleton<IMarkupTransform, ComponentRefMarkupTransform>();
         services.AddSingleton<IMarkupTransform, UrlReferenceTransform>();

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

@@ -0,0 +1,71 @@
+using System.Text.RegularExpressions;
+using BlazorWebFormsComponents.Cli.Pipeline;
+
+namespace BlazorWebFormsComponents.Cli.Transforms.Markup;
+
+/// <summary>
+/// Propagates a typed GridView's ItemType to child column components so TemplateField and
+/// other generic BWFC columns compile against the row item type instead of falling back to object.
+/// Object-typed grids are left unchanged.
+/// </summary>
+public sealed class GridViewColumnItemTypeTransform : IMarkupTransform
+{
+    public string Name => "GridViewColumnItemType";
+    public int Order => 705;
+
+    private static readonly Regex GridViewRegex = new(
+        @"(?<open><GridView\b[^>]*\bItemType=""(?<itemType>[^""]+)""[^>]*>)(?<inner>.*?)(?<close></GridView>)",
+        RegexOptions.Compiled | RegexOptions.Singleline);
+
+    private static readonly Regex ColumnTagRegex = new(
+        @"<(?<tag>BoundField|TemplateField|HyperLinkField|ButtonField)\b(?<attrs>[^>]*?)(?<close>\s*/?>)",
+        RegexOptions.Compiled | RegexOptions.Singleline);
+
+    private static readonly Regex ItemTypeRegex = new(
+        @"\bItemType=""(?<itemType>[^""]+)""",
+        RegexOptions.Compiled);
+
+    public string Apply(string content, FileMetadata metadata)
+    {
+        var previous = string.Empty;
+        do
+        {
+            previous = content;
+            content = GridViewRegex.Replace(content, RewriteGridView);
+        } while (!string.Equals(previous, content, StringComparison.Ordinal));
+
+        return content;
+    }
+
+    private static string RewriteGridView(Match match)
+    {
+        var gridItemType = match.Groups["itemType"].Value;
+        if (string.Equals(gridItemType, "object", StringComparison.Ordinal))
+        {
+            return match.Value;
+        }
+
+        var rewrittenInner = ColumnTagRegex.Replace(match.Groups["inner"].Value, column => RewriteColumn(column, gridItemType));
+        return match.Groups["open"].Value + rewrittenInner + match.Groups["close"].Value;
+    }
+
+    private static string RewriteColumn(Match match, string gridItemType)
+    {
+        var attrs = match.Groups["attrs"].Value;
+        var close = match.Groups["close"].Value;
+        var itemTypeMatch = ItemTypeRegex.Match(attrs);
+
+        if (!itemTypeMatch.Success)
+        {
+            return $"<{match.Groups["tag"].Value} ItemType=\"{gridItemType}\"{attrs}{close}";
+        }
+
+        if (!string.Equals(itemTypeMatch.Groups["itemType"].Value, "object", StringComparison.Ordinal))
+        {
+            return match.Value;
+        }
+
+        var rewrittenAttrs = ItemTypeRegex.Replace(attrs, $"ItemType=\"{gridItemType}\"", 1);
+        return $"<{match.Groups["tag"].Value}{rewrittenAttrs}{close}";
+    }
+}

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

@@ -4,8 +4,8 @@
 namespace BlazorWebFormsComponents.Cli.Transforms.Markup;
 
 /// <summary>
-/// Adds Context="Item" to typed item templates and rewrites generated @context references
-/// inside those templates to @Item so migrated BWFC data controls preserve Web Forms naming.
+/// Adds explicit template contexts for BWFC data-control fragments so generated markup stays
+/// structurally valid and readable for item, group, and layout templates.
 /// </summary>
 public sealed class TemplateContextTransform : IMarkupTransform
 {
@@ -16,15 +16,30 @@ public sealed class TemplateContextTransform : IMarkupTransform
         @"<(ItemTemplate|AlternatingItemTemplate|EditItemTemplate|InsertItemTemplate|SelectedItemTemplate)(?![^>]*\bContext=)([^>]*)>(.*?)</\1>",
         RegexOptions.Compiled | RegexOptions.Singleline);
 
+    private static readonly Regex ListViewPlaceholderTemplateBlockRegex = new(
+        @"<(GroupTemplate|LayoutTemplate)(?![^>]*\bContext=)([^>]*)>(.*?)</\1>",
+        RegexOptions.Compiled | RegexOptions.Singleline);
+
     public string Apply(string content, FileMetadata metadata)
     {
-        return ItemTemplateBlockRegex.Replace(content, static match =>
+        content = ItemTemplateBlockRegex.Replace(content, static match =>
         {
             var rewrittenInner = match.Groups[3].Value
                 .Replace("@context", "@Item", StringComparison.Ordinal)
                 .Replace("context.", "Item.", StringComparison.Ordinal);
 
             return $"<{match.Groups[1].Value} Context=\"Item\"{match.Groups[2].Value}>{rewrittenInner}</{match.Groups[1].Value}>";
         });
+
+        return ListViewPlaceholderTemplateBlockRegex.Replace(content, static match =>
+        {
+            var contextName = string.Equals(match.Groups[1].Value, "GroupTemplate", StringComparison.Ordinal)
+                ? "items"
+                : "groups";
+            var rewrittenInner = match.Groups[3].Value
+                .Replace("@context", $"@{contextName}", StringComparison.Ordinal);
+
+            return $"<{match.Groups[1].Value} Context=\"{contextName}\"{match.Groups[2].Value}>{rewrittenInner}</{match.Groups[1].Value}>";
+        });
     }
 }

tests/BlazorWebFormsComponents.Cli.Tests/TestHelpers.cs

@@ -209,6 +209,7 @@ public static MigrationPipeline CreateDefaultPipeline()
             new TemplateFieldChildComponentsTransform(),
             // Order 700-750: Attributes & refs
             new AttributeStripTransform(),
+            new GridViewColumnItemTypeTransform(),
             new EventWiringTransform(),
             new ComponentRefMarkupTransform(),
             new UrlReferenceTransform(),

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

@@ -0,0 +1,99 @@
+using BlazorWebFormsComponents.Cli.Pipeline;
+using BlazorWebFormsComponents.Cli.Transforms.Markup;
+
+namespace BlazorWebFormsComponents.Cli.Tests.TransformUnit;
+
+public class GridViewColumnItemTypeTransformTests
+{
+    private readonly GridViewColumnItemTypeTransform _transform = new();
+
+    private static FileMetadata TestMetadata => new()
+    {
+        SourceFilePath = "test.aspx",
+        OutputFilePath = "test.razor",
+        FileType = FileType.Page,
+        OriginalContent = string.Empty
+    };
+
+    [Fact]
+    public void UsesParentGridViewItemTypeForObjectColumns()
+    {
+        var input = """
+            <GridView ItemType="CartItem" AutoGenerateColumns="false">
+                <Columns>
+                    <BoundField ItemType="object" DataField="ProductID" />
+                    <TemplateField ItemType="object" HeaderText="Quantity">
+                        <ItemTemplate Context="Item">
+                            <TextBox Text="@Item.Quantity" />
+                        </ItemTemplate>
+                    </TemplateField>
+                </Columns>
+            </GridView>
+            """;
+
+        var result = _transform.Apply(input, TestMetadata);
+
+        Assert.Contains("<BoundField ItemType=\"CartItem\" DataField=\"ProductID\" />", result);
+        Assert.Contains("<TemplateField ItemType=\"CartItem\" HeaderText=\"Quantity\">", result);
+        Assert.DoesNotContain("ItemType=\"object\"", result);
+        Assert.Contains("</GridView>", result);
+    }
+
+    [Fact]
+    public void LeavesObjectTypedGridViewColumnsUntouched()
+    {
+        var input = """
+            <GridView ItemType="object" AutoGenerateColumns="false">
+                <Columns>
+                    <BoundField ItemType="object" DataField="ProductName" />
+                </Columns>
+            </GridView>
+            """;
+
+        var result = _transform.Apply(input, TestMetadata);
+
+        Assert.Equal(input, result);
+    }
+
+    [Fact]
+    public void PipelineRewritesWingtipShoppingCartColumnsToTypedFields()
+    {
+        var pipeline = TestHelpers.CreateDefaultPipeline();
+        var metadata = TestMetadata;
+
+        var result = pipeline.TransformMarkup("""
+            <asp:GridView ID="CartList" runat="server" AutoGenerateColumns="False" ItemType="WingtipToys.Models.CartItem">
+                <Columns>
+                    <asp:BoundField DataField="ProductID" HeaderText="ID" />
+                    <asp:TemplateField HeaderText="Quantity">
+                        <ItemTemplate>
+                            <asp:TextBox ID="PurchaseQuantity" runat="server" Text="<%#: Item.Quantity %>"></asp:TextBox>
+                        </ItemTemplate>
+                    </asp:TemplateField>
+                </Columns>
+            </asp:GridView>
+            """, metadata);
+
+        Assert.Contains("<GridView id=\"CartList\" AutoGenerateColumns=\"false\" ItemType=\"CartItem\">", result);
+        Assert.Contains("<BoundField ItemType=\"CartItem\" DataField=\"ProductID\" HeaderText=\"ID\" />", result);
+        Assert.Contains("<TemplateField ItemType=\"CartItem\" HeaderText=\"Quantity\">", result);
+        Assert.Contains("<ItemTemplate Context=\"Item\">", result);
+        Assert.Contains("Text=\"@Item.Quantity\"", result);
+        Assert.DoesNotContain("ItemType=\"object\"", result);
+        Assert.Equal(1, CountOccurrences(result, "<Columns>"));
+        Assert.Contains("</GridView>", result);
+    }
+
+    private static int CountOccurrences(string source, string target)
+    {
+        var count = 0;
+        var index = 0;
+        while ((index = source.IndexOf(target, index, StringComparison.Ordinal)) >= 0)
+        {
+            count++;
+            index += target.Length;
+        }
+
+        return count;
+    }
+}

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

@@ -52,4 +52,28 @@ public void PipelineAddsContextForGridTemplateField()
         Assert.Contains("<TemplateField ItemType=\"object\">", result);
         Assert.Contains("<ItemTemplate Context=\"Item\">@Item.Name</ItemTemplate>", result);
     }
+
+    [Fact]
+    public void PipelineAddsNamedContextForGroupTemplatePlaceholder()
+    {
+        var pipeline = TestHelpers.CreateDefaultPipeline();
+        var metadata = TestMetadata;
+
+        var result = pipeline.TransformMarkup("<asp:ListView ItemType=\"Widget\"><GroupTemplate><tr id=\"itemPlaceholder\" runat=\"server\"></tr></GroupTemplate></asp:ListView>", metadata);
+
+        Assert.Contains("<GroupTemplate Context=\"items\">", result);
+        Assert.Contains("@items", result);
+    }
+
+    [Fact]
+    public void PipelineAddsNamedContextForLayoutTemplatePlaceholder()
+    {
+        var pipeline = TestHelpers.CreateDefaultPipeline();
+        var metadata = TestMetadata;
+
+        var result = pipeline.TransformMarkup("<asp:ListView ItemType=\"Widget\"><LayoutTemplate><div id=\"groupPlaceholder\" runat=\"server\"></div></LayoutTemplate></asp:ListView>", metadata);
+
+        Assert.Contains("<LayoutTemplate Context=\"groups\">", result);
+        Assert.Contains("@groups", result);
+    }
 }