Paint the full line strong when there are no intra-line spans

Soft line tints (RemovedLineBackground / AddedLineBackground) are
only the right base layer when the intra-line colorizer is about to
overlay strong red/green sub-spans on top -- they narrow the claim
from "this whole line changed" to "specifically these characters
inside the line". With no spans, the soft tint left the user with a
faint "something changed somewhere in this region" signal and no
visual emphasis on the changed line at all -- the exact failure mode
the previous yellow-with-no-spans fix targeted, just in a different
color.

The new rule is uniform: any line whose highlight has no intra-line
spans gets the strong intra-line brush across the full row; only
Modified (which by DiffHighlightMap contract always carries spans)
keeps the soft yellow base layer for the colorizer to paint over.
This applies to:

- Pure inserts and pure deletes (no opposing side to compare against).
- Paired delete+insert lines under intra-line off (no pairing
  happens, both sides spill as Deleted/Inserted).
- Paired delete+insert lines under intra-line on that the pairing-
  viability policy demoted to unpaired (the demote path emits null
  spans on purpose).

Implementation: brush selection extracted to a shared internal
LineBackgroundBrushSelector that both DiffBackgroundRenderer (side-
by-side) and InlineDiffBackgroundRenderer (inline) call into, with
unit tests covering every (DiffSide, DiffLineKind) cell. The previous
inline implementation drifted slightly from side-by-side (it didn't
need a side discriminator); the shared selector is the only place
the rule lives now, so future scheme tweaks stay consistent across
both render modes.

Side benefit: the side-by-side and inline line tints now match the
strong colors the hunk overview bar already uses for its mini-map
markers, so the rendering story is consistent vertically too.

AI-Local-Session: 4519f6b6-393a-4476-8efa-410e5396c3a9
AI-Cloud-Session: 72f9e474-60ab-42c2-b2a0-28fee827cbbb
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Geeven Singh

CHANGELOG.md

@@ -12,6 +12,22 @@ body. Keep section headings exact and write notes in Markdown.
 
 ## [Unreleased]
 
+### Changed
+
+- **Lines with no intra-line spans now paint with the strong
+  (intra-line) tint across the full row, not the soft line tint.**
+  Previously, pure inserts/deletes and paired-but-not-shown changes
+  (intra-line off, or paired lines the similarity policy demoted)
+  rendered with the same faint background as everything else in the
+  hunk — leaving the user with a subtle "something changed" signal
+  but no visual emphasis on the changed line itself. The new rule is
+  uniform: if there are no inner red/green spans, the whole row gets
+  the strong tint ("all of this is the change"); if there are spans,
+  the soft yellow ModifiedLineBackground stays as the base layer and
+  the colorizer overlays the strong spans on top. This applies in
+  side-by-side and inline modes, and matches the strong colors the
+  hunk overview bar already uses for its mini-map markers.
+
 ### Fixed
 
 - **Paired delete+insert lines no longer render as yellow "Modified"

DiffViewer.Tests/Rendering/LineBackgroundBrushSelectorTests.cs

@@ -0,0 +1,86 @@
+using System.Windows.Media;
+using DiffViewer.Models;
+using DiffViewer.Rendering;
+using FluentAssertions;
+using Xunit;
+using DiffSide = DiffViewer.Rendering.DiffSide;
+
+namespace DiffViewer.Tests.Rendering;
+
+public sealed class LineBackgroundBrushSelectorTests
+{
+    private static readonly DiffColorScheme Scheme = DiffColorScheme.Classic;
+
+    [Fact]
+    public void Pick_LeftDeleted_ReturnsStrongRemovedBrush()
+    {
+        // The whole point of the strong-when-no-spans rule: a Deleted
+        // line on the left side has, by DiffHighlightMap contract, no
+        // intra-line spans -- so the brush must be strong, not soft.
+        var brush = LineBackgroundBrushSelector.Pick(DiffSide.Left, DiffLineKind.Deleted, Scheme);
+
+        brush.Should().BeSameAs(Scheme.RemovedIntraLineBackground);
+        brush.Should().NotBeSameAs(Scheme.RemovedLineBackground);
+    }
+
+    [Fact]
+    public void Pick_RightInserted_ReturnsStrongAddedBrush()
+    {
+        var brush = LineBackgroundBrushSelector.Pick(DiffSide.Right, DiffLineKind.Inserted, Scheme);
+
+        brush.Should().BeSameAs(Scheme.AddedIntraLineBackground);
+        brush.Should().NotBeSameAs(Scheme.AddedLineBackground);
+    }
+
+    [Fact]
+    public void Pick_InlineDeleted_ReturnsStrongRemovedBrush()
+    {
+        var brush = LineBackgroundBrushSelector.Pick(DiffSide.Inline, DiffLineKind.Deleted, Scheme);
+
+        brush.Should().BeSameAs(Scheme.RemovedIntraLineBackground);
+    }
+
+    [Fact]
+    public void Pick_InlineInserted_ReturnsStrongAddedBrush()
+    {
+        var brush = LineBackgroundBrushSelector.Pick(DiffSide.Inline, DiffLineKind.Inserted, Scheme);
+
+        brush.Should().BeSameAs(Scheme.AddedIntraLineBackground);
+    }
+
+    [Theory]
+    [InlineData(DiffSide.Left)]
+    [InlineData(DiffSide.Right)]
+    [InlineData(DiffSide.Inline)]
+    public void Pick_Modified_ReturnsSoftModifiedBrush(DiffSide side)
+    {
+        // Modified means DiffHighlightMap also attached intra-line spans;
+        // the IntraLineColorizer overlays the strong red/green spans on
+        // top of the soft yellow background, so the soft brush is the
+        // correct base layer.
+        var brush = LineBackgroundBrushSelector.Pick(side, DiffLineKind.Modified, Scheme);
+
+        brush.Should().BeSameAs(Scheme.ModifiedLineBackground);
+    }
+
+    [Theory]
+    [InlineData(DiffSide.Left, DiffLineKind.Context)]
+    [InlineData(DiffSide.Right, DiffLineKind.Context)]
+    [InlineData(DiffSide.Inline, DiffLineKind.Context)]
+    [InlineData(DiffSide.Left, DiffLineKind.Inserted)] // wrong side
+    [InlineData(DiffSide.Right, DiffLineKind.Deleted)] // wrong side
+    public void Pick_NonTintedCases_ReturnsTransparent(DiffSide side, DiffLineKind kind)
+    {
+        var brush = LineBackgroundBrushSelector.Pick(side, kind, Scheme);
+
+        brush.Should().BeSameAs(Brushes.Transparent);
+    }
+
+    [Fact]
+    public void Pick_NullScheme_ThrowsArgumentNullException()
+    {
+        var act = () => LineBackgroundBrushSelector.Pick(DiffSide.Left, DiffLineKind.Deleted, null!);
+
+        act.Should().Throw<ArgumentNullException>();
+    }
+}

DiffViewer/Rendering/DiffBackgroundRenderer.cs

@@ -33,6 +33,10 @@ public enum DiffSide
 /// its highlight dictionary from <see cref="LineHighlights"/> on every
 /// <see cref="Draw"/>, so updating the map plus calling
 /// <c>TextView.Redraw()</c> is enough to repaint.
+///
+/// <para>Brush selection is delegated to
+/// <see cref="LineBackgroundBrushSelector"/>; see its summary for the
+/// strong-vs-soft rule.</para>
 /// </summary>
 public sealed class DiffBackgroundRenderer : IBackgroundRenderer
 {
@@ -59,7 +63,7 @@ public void Draw(TextView textView, DrawingContext drawingContext)
             int docLine = visualLine.FirstDocumentLine.LineNumber;
             if (!LineHighlights.TryGetValue(docLine, out var highlight)) continue;
 
-            Brush brush = PickBrush(highlight.Kind);
+            Brush brush = LineBackgroundBrushSelector.Pick(_side, highlight.Kind, _scheme);
 
             // Paint the full line width so the tint extends to the right edge
             // even on short lines; matches GitHub / VS Code line-diff style.
@@ -75,13 +79,4 @@ public void Draw(TextView textView, DrawingContext drawingContext)
             }
         }
     }
-
-    private Brush PickBrush(DiffLineKind kind) => (_side, kind) switch
-    {
-        (DiffSide.Left, DiffLineKind.Deleted) => _scheme.RemovedLineBackground,
-        (DiffSide.Left, DiffLineKind.Modified) => _scheme.ModifiedLineBackground,
-        (DiffSide.Right, DiffLineKind.Inserted) => _scheme.AddedLineBackground,
-        (DiffSide.Right, DiffLineKind.Modified) => _scheme.ModifiedLineBackground,
-        _ => Brushes.Transparent,
-    };
 }

DiffViewer/Rendering/InlineDiffBackgroundRenderer.cs

@@ -11,6 +11,10 @@ namespace DiffViewer.Rendering;
 /// <see cref="Draw"/> and paints the appropriate brush for that kind.
 /// Hunk-header lines and blank separators are absent from the dictionary
 /// and rendered without a tint.
+///
+/// <para>Brush selection is delegated to
+/// <see cref="LineBackgroundBrushSelector"/> (with <see cref="DiffSide.Inline"/>);
+/// see its summary for the strong-vs-soft rule.</para>
 /// </summary>
 public sealed class InlineDiffBackgroundRenderer : IBackgroundRenderer
 {
@@ -35,13 +39,7 @@ public void Draw(TextView textView, DrawingContext drawingContext)
             int docLine = visualLine.FirstDocumentLine.LineNumber;
             if (!LineHighlights.TryGetValue(docLine, out var highlight)) continue;
 
-            Brush brush = highlight.Kind switch
-            {
-                DiffLineKind.Inserted => _scheme.AddedLineBackground,
-                DiffLineKind.Deleted => _scheme.RemovedLineBackground,
-                DiffLineKind.Modified => _scheme.ModifiedLineBackground,
-                _ => Brushes.Transparent,
-            };
+            Brush brush = LineBackgroundBrushSelector.Pick(DiffSide.Inline, highlight.Kind, _scheme);
 
             foreach (var rect in BackgroundGeometryBuilder.GetRectsFromVisualSegment(
                 textView, visualLine, 0, int.MaxValue))

DiffViewer/Rendering/LineBackgroundBrushSelector.cs

@@ -0,0 +1,54 @@
+using System.Windows.Media;
+using DiffViewer.Models;
+
+namespace DiffViewer.Rendering;
+
+/// <summary>
+/// Resolves the per-line background brush both
+/// <see cref="DiffBackgroundRenderer"/> (side-by-side) and
+/// <see cref="InlineDiffBackgroundRenderer"/> (inline) paint.
+///
+/// <para>The rule is uniform across both modes: <em>any line with no
+/// intra-line spans gets the strong intra-line brush; lines with spans
+/// get the soft modified tint and the colorizer paints the strong
+/// spans on top of it</em>. By contract, <see cref="DiffHighlightMap"/>
+/// emits <see cref="DiffLineKind.Modified"/> only when intra-line
+/// analysis produced spans, and emits <see cref="DiffLineKind.Deleted"/>
+/// / <see cref="DiffLineKind.Inserted"/> with null spans in every other
+/// case (pure delete/insert, intra-line off, demote path). The
+/// selector keys off <see cref="DiffLineKind"/> alone because that
+/// contract makes spans-vs-no-spans equivalent to
+/// Modified-vs-Deleted/Inserted.</para>
+///
+/// <para>Why strong-when-no-spans: the strong brush says "this whole
+/// rectangle is what changed"; the soft brush only makes sense when
+/// the colorizer is about to overlay strong sub-spans that narrow the
+/// claim ("here within the line"). Painting soft without overlay leaves
+/// the user with a faint "something changed" signal with no indication
+/// of where — which is the bug this rule fixes for the no-spans cases.</para>
+/// </summary>
+internal static class LineBackgroundBrushSelector
+{
+    public static Brush Pick(DiffSide side, DiffLineKind kind, DiffColorScheme scheme)
+    {
+        ArgumentNullException.ThrowIfNull(scheme);
+
+        return (side, kind) switch
+        {
+            // Strong full-line tints for pure inserts/deletes and for
+            // paired-but-no-spans (intra-line off or demote path).
+            (DiffSide.Left, DiffLineKind.Deleted) => scheme.RemovedIntraLineBackground,
+            (DiffSide.Right, DiffLineKind.Inserted) => scheme.AddedIntraLineBackground,
+            (DiffSide.Inline, DiffLineKind.Deleted) => scheme.RemovedIntraLineBackground,
+            (DiffSide.Inline, DiffLineKind.Inserted) => scheme.AddedIntraLineBackground,
+
+            // Soft yellow for Modified — the colorizer paints strong
+            // red/green spans on top so the yellow shows through only in
+            // the unchanged-within-the-line gaps.
+            (_, DiffLineKind.Modified) => scheme.ModifiedLineBackground,
+
+            // Context lines and anything else: no tint.
+            _ => Brushes.Transparent,
+        };
+    }
+}