Speed up diagnostic rendering

[ntBre]

Summary

We got a report of Ruff slowing down over time, which I reproduced with
hyperfine and the latest releases in each Ruff minor version series:

Command	Mean [s]	Min [s]	Max [s]	Relative
ruff 0.5	3.194 ± 0.023	3.164	3.234	1.37 ± 0.01
ruff 0.6	3.144 ± 0.048	3.086	3.224	1.35 ± 0.02
ruff 0.7	3.170 ± 0.024	3.147	3.220	1.36 ± 0.01
ruff 0.8	2.337 ± 0.018	2.299	2.356	1.00
ruff 0.9	5.120 ± 0.281	4.970	5.910	2.19 ± 0.12
ruff 0.10	5.015 ± 0.023	4.981	5.044	2.15 ± 0.02
ruff 0.11	5.071 ± 0.028	5.011	5.105	2.17 ± 0.02
ruff 0.12	6.065 ± 0.056	5.982	6.176	2.59 ± 0.03
ruff 0.13	6.074 ± 0.053	6.011	6.170	2.60 ± 0.03
ruff 0.14	5.824 ± 0.046	5.766	5.921	2.49 ± 0.03
ruff 0.15	5.987 ± 0.102	5.868	6.188	2.56 ± 0.05

This benchmark is dominated by diagnostic rendering because it
runs on CPython with --select ALL, but I still thought it was interesting
and worth looking into.

Benchmarking script

set -euo pipefail

export PATH="$HOME/.cargo/bin:$PATH"

TARGET="${1:-crates/ruff_linter/resources/test/cpython}"
BIN_DIR="/tmp/ruff-bench"
MINOR_VERSIONS=("0.5" "0.6" "0.7" "0.8" "0.9" "0.10" "0.11" "0.12" "0.13" "0.14" "0.15")

mkdir -p "$BIN_DIR"

case "$(uname -s)-$(uname -m)" in
    Linux-x86_64)   TRIPLE="x86_64-unknown-linux-gnu" ;;
    Linux-aarch64)  TRIPLE="aarch64-unknown-linux-gnu" ;;
    Darwin-x86_64)  TRIPLE="x86_64-apple-darwin" ;;
    Darwin-arm64)   TRIPLE="aarch64-apple-darwin" ;;
    *) echo "Unsupported platform: $(uname -s)-$(uname -m)"; exit 1 ;;
esac

ASSET="ruff-${TRIPLE}.tar.gz"

echo "Fetching release list..."
RELEASES=$(gh release list --repo astral-sh/ruff --limit 500 --json tagName -q '.[].tagName')

for minor in "${MINOR_VERSIONS[@]}"; do
    # Find the latest patch release for this minor version
    tag=$(echo "$RELEASES" | grep "^${minor}\." | sort -V | tail -1)
    if [[ -z "$tag" ]]; then
        echo "No release found for $minor, skipping"
        continue
    fi

    dest="$BIN_DIR/ruff-${minor}"
    if [[ -x "$dest" ]]; then
        echo "Already have ruff $tag at $dest"
        continue
    fi

    echo "Downloading ruff $tag..."
    tmpdir=$(mktemp -d)
    gh release download "$tag" --repo astral-sh/ruff --pattern "$ASSET" --dir "$tmpdir"
    tar xzf "$tmpdir/$ASSET" -C "$tmpdir"
    cp "$tmpdir/ruff-${TRIPLE}/ruff" "$dest"
    chmod +x "$dest"
    rm -rf "$tmpdir"
done

OUTFILE="bench-versions-$(date +%Y%m%d-%H%M%S).md"
HYPERFINE_ARGS=(--warmup 1 --export-markdown "$OUTFILE")
for minor in "${MINOR_VERSIONS[@]}"; do
    bin="$BIN_DIR/ruff-${minor}"
    if [[ -x "$bin" ]]; then
        HYPERFINE_ARGS+=(-n "ruff $minor" "$bin check --isolated --select ALL $TARGET > /dev/null 2>&1 || true")
    fi
done

echo ""
echo "Running benchmarks against: $TARGET"
echo "Results will be saved to: $OUTFILE"
echo ""
hyperfine "${HYPERFINE_ARGS[@]}" | tee -a "$OUTFILE"

I started out focused on StyledBuffer::puts, but found a handful of related
improvements that I included together in this PR. From a quick glance, I don't
think we have any benchmarks for diagnostic rendering, so unfortunately
I don't expect this to show up in the codspeed results, but the benchmarks for
CPython with all rules show a very significant improvement:

Command	Mean [s]	Min [s]	Max [s]	Relative
main	6.222 ± 0.074	6.116	6.341	1.67 ± 0.02
2db3183	5.770 ± 0.037	5.691	5.813	1.55 ± 0.01
6a1b59e	5.304 ± 0.067	5.215	5.417	1.43 ± 0.02
c89d34e	5.207 ± 0.066	5.121	5.296	1.40 ± 0.02
5da1078	4.094 ± 0.016	4.068	4.116	1.10 ± 0.01
8147494	3.718 ± 0.010	3.706	3.739	1.00

For a total of a ~67% speedup compared to main. The most surprising change was simply replacing two write! calls with String::push, which led to the majority of the improvement.

As a sanity check, I also ran the same final benchmarking script on our python directory to make sure this doesn't regress performance on much smaller projects with many fewer diagnostics, and the same general trend is observed, though with a much smaller effect size:

Command	Mean [ms]	Min [ms]	Max [ms]	Relative
main	20.3 ± 0.7	19.1	22.6	1.10 ± 0.05
2db3183	20.2 ± 0.7	18.9	22.5	1.09 ± 0.06
6a1b59e	19.8 ± 0.9	18.4	26.8	1.07 ± 0.06
c89d34e	19.6 ± 0.8	18.2	23.3	1.06 ± 0.06
5da1078	18.6 ± 0.6	17.5	21.0	1.01 ± 0.05
8147494	18.5 ± 0.7	17.3	20.4	1.00

Test Plan

Benchmarks above

[astral-sh-bot]

ruff-ecosystem results

Linter (stable)

✅ ecosystem check detected no linter changes.

Linter (preview)

✅ ecosystem check detected no linter changes.

[ntBre]

I checked the upstream implementation to see if they'd done anything similar, but we've diverged a bit already:

https://github.com/rust-lang/annotate-snippets-rs/blob/45424f56bb51049361366c781d0e5acefa7ad677/src/renderer/render.rs#L2538

after rust-lang/annotate-snippets-rs@84d07af specifically.

[MichaReiser]

Nit: You could try the following, but it's not unlikely that it is slower, if the current contains call use SIMD or gets vectorized:

    let mut output = String::new();
    let mut last_index = 0usize;

    for (index, c) in str.char_indices() {
        let replacement = match c {
            '\t' => "    ",   // We do our own tab replacement
            '\u{200D}' => "", // Replace ZWJ with nothing for consistent terminal output of grapheme clusters.
            '\u{202A}' => "", // The following unicode text flow control characters are inconsistently
            '\u{202B}' => "", // supported across CLIs and can cause confusion due to the bytes on disk
            '\u{202D}' => "", // not corresponding to the visible source code, so we replace them always.
            '\u{202E}' => "",
            '\u{2066}' => "",
            '\u{2067}' => "",
            '\u{2068}' => "",
            '\u{202C}' => "",
            '\u{2069}' => "",
            _ => continue,
        };

        if output.is_empty() {
            output.reserve(str.len());
        }

        output.push_str(&str[last_index..index]);
        output.push_str(replacement);
        last_index = index + c.len_utf8();
    }

    if output.is_empty() {
        Cow::Borrowed(str)
    } else {
        output.push_str(&str[last_index..]);
        Cow::Owned(output)
    }

[ntBre]

Thanks, that did look like a good idea, but it appears to be slightly slower, at least on CPython and on my machine:

Command	Mean [s]	Min [s]	Max [s]	Relative
8147494	3.713 ± 0.038	3.665	3.778	1.00
1c764d1 (this commit locally)	3.811 ± 0.064	3.768	3.987	1.03 ± 0.02

I think I'll stick with the current version for now.

[MichaReiser]

Nice!

[MichaReiser]

Nit: You could try the following, but it's not unlikely that it is slower, if the current contains call use SIMD or gets vectorized:

    let mut output = String::new();
    let mut last_index = 0usize;

    for (index, c) in str.char_indices() {
        let replacement = match c {
            '\t' => "    ",   // We do our own tab replacement
            '\u{200D}' => "", // Replace ZWJ with nothing for consistent terminal output of grapheme clusters.
            '\u{202A}' => "", // The following unicode text flow control characters are inconsistently
            '\u{202B}' => "", // supported across CLIs and can cause confusion due to the bytes on disk
            '\u{202D}' => "", // not corresponding to the visible source code, so we replace them always.
            '\u{202E}' => "",
            '\u{2066}' => "",
            '\u{2067}' => "",
            '\u{2068}' => "",
            '\u{202C}' => "",
            '\u{2069}' => "",
            _ => continue,
        };

        if output.is_empty() {
            output.reserve(str.len());
        }

        output.push_str(&str[last_index..index]);
        output.push_str(replacement);
        last_index = index + c.len_utf8();
    }

    if output.is_empty() {
        Cow::Borrowed(str)
    } else {
        output.push_str(&str[last_index..]);
        Cow::Owned(output)
    }

[MichaReiser]

Nit: Not sure if this helps. It probalby depends on how common it is that `line is empty

Suggested change

	let char_count = string.chars().count();
	if char_count == 0 {
	return;
	}
	self.ensure_lines(line);
	let needed = col + char_count;
	if string.is_empty() {
	return;
	}
	self.ensure_lines(line);
	let char_count = string.chars().count();
	let needed = col + char_count;

[ntBre]

Command	Mean [s]	Min [s]	Max [s]	Relative
8147494	3.717 ± 0.022	3.686	3.747	1.00
c221867	3.743 ± 0.025	3.710	3.805	1.01 ± 0.01

This one is also "slightly slower", but the intervals overlap at least, so I think it's basically equivalent and looks nicer anyway. Thanks!