Invalid patch highlighting for indented code

[0x2a-42]

I noticed in my Lua linter, that the highlighting of patches is wrong, if the code is indented. It works correctly if the code is not indented.

do
  local function f()
    print()
  end
end

Here is a minimal reproducer.

use annotate_snippets::{Group, Level, Patch, Renderer, Snippet};

fn main() {
    let source = "do\n  local function f()\n    print()\n  end\nend\n";
    let delete_span = 5..41;
    let group = Group::with_title(Level::HELP.secondary_title("delete the definition"))
        .element(Snippet::source(source).patch(Patch::new(delete_span, "")));
    let renderer = Renderer::styled();
    println!("{}", renderer.render(&[group]));
}

[0x2a-42]

The highlighting works without indentation because here the following code is used, that removes whole lines.

annotate-snippets-rs/src/renderer/render.rs

Lines 1498 to 1521 in 5b99daa

	if lines.clone().next().is_none() {
	// Account for a suggestion to completely remove a line(s) with whitespace (#94192).
	for line in line_start.line..=line_end.line {
	buffer.puts(
	row_num - 1 + line - line_start.line,
	0,
	&maybe_anonymized(renderer, line, max_line_num_len),
	ElementStyle::LineNumber,
	);
	buffer.puts(
	row_num - 1 + line - line_start.line,
	max_line_num_len + 1,
	"- ",
	ElementStyle::Removal,
	);
	buffer.puts(
	row_num - 1 + line - line_start.line,
	max_line_num_len + 3,
	&normalize_whitespace(sm.get_line(line).unwrap()),
	ElementStyle::Removal,
	);
	}
	row_num += line_end.line - line_start.line;
	}

If a line is only partially removed the colorization happens here instead.

annotate-snippets-rs/src/renderer/render.rs

Lines 1762 to 1768 in 5b99daa

	buffer.set_style_range(
	row,
	padding + start,
	padding + end,
	ElementStyle::Removal,
	true,
	);

This code assumes that there is at least one addition in the diff, which should be the case if a line was partially removed.

annotate-snippets-rs/src/renderer/render.rs

Lines 1684 to 1710 in 5b99daa

	// Below, there's some tricky buffer indexing going on. `row_num` at this
	// point corresponds to:
	//
	// |
	// LL | CODE
	// | ++++ <- `row_num`
	//
	// in the buffer. When we have a diff format output, we end up with
	//
	// |
	// LL - OLDER <- row_num - 2
	// LL + NEWER
	// | <- row_num
	//
	// The `row_num - 2` is to select the buffer line that has the "old version
	// of the diff" at that point. When the removal is a single line, `i` is
	// `0`, `newlines` is `1` so `(newlines - i - 1)` ends up being `0`, so row
	// points at `LL - OLDER`. When the removal corresponds to multiple lines,
	// we end up with `newlines > 1` and `i` being `0..newlines - 1`.
	//
	// |
	// LL - OLDER <- row_num - 2 - (newlines - last_i - 1)
	// LL - CODE
	// LL - BEING
	// LL - REMOVED <- row_num - 2 - (newlines - first_i - 1)
	// LL + NEWER
	// | <- row_num

This assumption is used in the calculation of the row value.

annotate-snippets-rs/src/renderer/render.rs

Line 1730 in 5b99daa

let row = (row_num - 2 - (offset - i - 1)).max(min_row);

When only whitespaces remain in the partially removed line, this addition is however not written to the buffer. So in my example the values of row are [2, 2, 3] instead of [2, 3, 4], which explains why line 3 gets the colorization that should be applied to line 4.

I see three possible solutions.

1. Treat partially removed lines where only whitespaces remain as completely removed lines.
2. Somehow show trailing whitespace additions in the diff.
3. Check if there was an addition to decide if 2 or 1 should be subtracted from row.