⚡️ Speed up function generate_unified_diff by 99% in PR #274 (skip-formatting-for-large-diffs)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #274

If you approve this dependent PR, these changes will be merged into the original PR branch skip-formatting-for-large-diffs.

This PR will be automatically closed if the original PR is merged.

---

📄 99% (0.99x) speedup for generate_unified_diff in codeflash/code_utils/formatter.py

⏱️ Runtime : 15.3 milliseconds → 7.66 milliseconds (best of 269 runs)

📝 Explanation and details

Here is an optimized version of your program.
Key improvements.

• Remove the regular expression and use the built-in splitlines(keepends=True), which is significantly faster for splitting text into lines, especially on large files.
• Use extend instead of repeated append calls for cases with two appends.
• Minor local optimizations (localize function, reduce attribute lookups).

Performance explanation.

• The regex-based splitting was responsible for a significant portion of time. str.splitlines(keepends=True) is implemented in C and avoids unnecessary regex matching.
• Using local variable lookups (e.g. append = diff_output.append) is slightly faster inside loops that append frequently.
• extend is ever-so-slightly faster (in CPython) than multiple append calls for the rare "no newline" case.

---

This code produces exactly the same output as your original, but should be much faster (especially for large inputs).

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 49 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	✅ 1 Passed
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests Details

from __future__ import annotations

import difflib
import re

# imports
import pytest  # used for our unit tests
from codeflash.code_utils.formatter import generate_unified_diff

# unit tests

# ------------------------
# Basic Test Cases
# ------------------------

def test_identical_strings():
    """Test diff for two identical strings."""
    a = "line1\nline2\nline3\n"
    b = "line1\nline2\nline3\n"
    codeflash_output = generate_unified_diff(a, b, "a.txt", "b.txt"); diff = codeflash_output
    # Unified diff for identical files should only have the headers
    lines = diff.splitlines()

def test_simple_addition():
    """Test diff when a line is added."""
    a = "line1\nline2\n"
    b = "line1\nline2\nline3\n"
    codeflash_output = generate_unified_diff(a, b, "a.txt", "b.txt"); diff = codeflash_output

def test_simple_deletion():
    """Test diff when a line is deleted."""
    a = "line1\nline2\nline3\n"
    b = "line1\nline2\n"
    codeflash_output = generate_unified_diff(a, b, "a.txt", "b.txt"); diff = codeflash_output

def test_simple_modification():
    """Test diff when a line is changed."""
    a = "line1\nline2\nline3\n"
    b = "line1\nlineX\nline3\n"
    codeflash_output = generate_unified_diff(a, b, "a.txt", "b.txt"); diff = codeflash_output

def test_multiple_changes():
    """Test diff with multiple changes (add, delete, modify)."""
    a = "a\nb\nc\nd\n"
    b = "a\nx\nc\ny\nd\nz\n"
    codeflash_output = generate_unified_diff(a, b, "a.txt", "b.txt"); diff = codeflash_output

# ------------------------
# Edge Test Cases
# ------------------------

def test_empty_original_and_modified():
    """Test diff when both strings are empty."""
    a = ""
    b = ""
    codeflash_output = generate_unified_diff(a, b, "a.txt", "b.txt"); diff = codeflash_output
    lines = diff.splitlines()

def test_empty_original_nonempty_modified():
    """Test diff when original is empty and modified is not."""
    a = ""
    b = "foo\nbar\n"
    codeflash_output = generate_unified_diff(a, b, "a.txt", "b.txt"); diff = codeflash_output

def test_nonempty_original_empty_modified():
    """Test diff when original is not empty and modified is empty."""
    a = "foo\nbar\n"
    b = ""
    codeflash_output = generate_unified_diff(a, b, "a.txt", "b.txt"); diff = codeflash_output

def test_diff_with_no_trailing_newline():
    """Test diff when one or both files lack a trailing newline."""
    a = "foo\nbar"
    b = "foo\nbaz"
    codeflash_output = generate_unified_diff(a, b, "a.txt", "b.txt"); diff = codeflash_output

def test_diff_with_crlf_and_lf():
    """Test diff with different line endings (CRLF vs LF)."""
    a = "foo\r\nbar\r\nbaz\r\n"
    b = "foo\nbar\nbaz\n"
    codeflash_output = generate_unified_diff(a, b, "a.txt", "b.txt"); diff = codeflash_output
    # Should be no difference, as lines are the same
    lines = diff.splitlines()

def test_diff_with_only_carriage_return():
    """Test diff with only CR line endings."""
    a = "foo\rbar\rbaz\r"
    b = "foo\rbar\rqux\r"
    codeflash_output = generate_unified_diff(a, b, "a.txt", "b.txt"); diff = codeflash_output

def test_unicode_and_multibyte_characters():
    """Test diff with unicode/multibyte characters."""
    a = "αβγ\nδεζ\n"
    b = "αβγ\nδεη\n"
    codeflash_output = generate_unified_diff(a, b, "a.txt", "b.txt"); diff = codeflash_output

def test_diff_with_blank_lines():
    """Test diff with blank lines and whitespace."""
    a = "foo\n\nbar\n"
    b = "foo\n\nbaz\n"
    codeflash_output = generate_unified_diff(a, b, "a.txt", "b.txt"); diff = codeflash_output

def test_diff_with_leading_and_trailing_whitespace():
    """Test diff with lines differing only in leading/trailing whitespace."""
    a = "foo \nbar\n"
    b = "foo\nbar\n"
    codeflash_output = generate_unified_diff(a, b, "a.txt", "b.txt"); diff = codeflash_output

def test_diff_with_very_long_lines():
    """Test diff with very long lines."""
    long_line1 = "a" * 500 + "\n"
    long_line2 = "b" * 500 + "\n"
    a = long_line1
    b = long_line2
    codeflash_output = generate_unified_diff(a, b, "a.txt", "b.txt"); diff = codeflash_output

# ------------------------
# Large Scale Test Cases
# ------------------------

def test_large_file_addition():
    """Test diff performance and correctness with a large addition."""
    orig = "\n".join([f"line{i}" for i in range(500)]) + "\n"
    mod = orig + "new_line\n"
    codeflash_output = generate_unified_diff(orig, mod, "a.txt", "b.txt"); diff = codeflash_output

def test_large_file_deletion():
    """Test diff performance and correctness with a large deletion."""
    orig = "\n".join([f"line{i}" for i in range(500)]) + "\nextra_line\n"
    mod = "\n".join([f"line{i}" for i in range(500)]) + "\n"
    codeflash_output = generate_unified_diff(orig, mod, "a.txt", "b.txt"); diff = codeflash_output

def test_large_file_modification_middle():
    """Test diff with a large file and a change in the middle."""
    orig_lines = [f"line{i}" for i in range(1000)]
    mod_lines = orig_lines.copy()
    mod_lines[500] = "changed_line"
    orig = "\n".join(orig_lines) + "\n"
    mod = "\n".join(mod_lines) + "\n"
    codeflash_output = generate_unified_diff(orig, mod, "a.txt", "b.txt"); diff = codeflash_output

def test_large_file_no_difference():
    """Test diff with two large identical files."""
    orig = "\n".join([f"line{i}" for i in range(1000)]) + "\n"
    mod = orig
    codeflash_output = generate_unified_diff(orig, mod, "a.txt", "b.txt"); diff = codeflash_output
    lines = diff.splitlines()

def test_large_file_all_lines_different():
    """Test diff with two large files where all lines are different."""
    orig = "\n".join([f"lineA{i}" for i in range(1000)]) + "\n"
    mod = "\n".join([f"lineB{i}" for i in range(1000)]) + "\n"
    codeflash_output = generate_unified_diff(orig, mod, "a.txt", "b.txt"); diff = codeflash_output
    # But all lines should be present in diff
    for i in range(0, 1000, 100):  # Sample every 100th line
        pass

def test_large_file_with_no_trailing_newline():
    """Test large file with no trailing newline in one or both files."""
    orig = "\n".join([f"line{i}" for i in range(999)])  # no trailing newline
    mod = orig + "\nlastline"
    codeflash_output = generate_unified_diff(orig, mod, "a.txt", "b.txt"); diff = codeflash_output

# ------------------------
# Miscellaneous/Additional Edge Cases
# ------------------------

def test_diff_with_tabs():
    """Test diff with lines that include tabs."""
    a = "foo\tbar\nbaz\n"
    b = "foo\tbaz\nbaz\n"
    codeflash_output = generate_unified_diff(a, b, "a.txt", "b.txt"); diff = codeflash_output

def test_diff_with_only_newlines():
    """Test diff with only newline characters."""
    a = "\n\n\n"
    b = "\n\n"
    codeflash_output = generate_unified_diff(a, b, "a.txt", "b.txt"); diff = codeflash_output

def test_diff_with_comment_lines():
    """Test diff with lines that look like diff syntax."""
    a = "--- not_a_header\n+++ not_a_header\n@@ not_a_hunk\n"
    b = "--- not_a_header\n+++ not_a_header\n@@ a_real_hunk\n"
    codeflash_output = generate_unified_diff(a, b, "a.txt", "b.txt"); diff = codeflash_output

def test_diff_with_windows_and_unix_mix():
    """Test diff with a mix of Windows and Unix newlines in the same file."""
    a = "foo\r\nbar\nbaz\r\n"
    b = "foo\nbar\r\nbaz\n"
    codeflash_output = generate_unified_diff(a, b, "a.txt", "b.txt"); diff = codeflash_output
    # Should be no difference, as lines are the same
    lines = diff.splitlines()

def test_diff_with_non_ascii_bytes():
    """Test diff with non-ASCII bytes in the string."""
    a = "foo\x80bar\nbaz\n"
    b = "foo\x80bar\nqux\n"
    codeflash_output = generate_unified_diff(a, b, "a.txt", "b.txt"); diff = codeflash_output
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from __future__ import annotations

import difflib
import re

# imports
import pytest  # used for our unit tests
from codeflash.code_utils.formatter import generate_unified_diff

# unit tests

# --- Basic Test Cases ---

def test_identical_strings():
    # No difference between original and modified
    original = "line1\nline2\nline3\n"
    modified = "line1\nline2\nline3\n"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output

def test_single_line_change():
    # Only one line differs
    original = "line1\nline2\nline3\n"
    modified = "line1\nlineX\nline3\n"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output
    # Check for correct diff output
    lines = diff.splitlines()

def test_line_addition():
    # Line added in modified
    original = "line1\nline2\n"
    modified = "line1\nline2\nline3\n"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output

def test_line_deletion():
    # Line deleted in modified
    original = "line1\nline2\nline3\n"
    modified = "line1\nline2\n"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output

def test_multiple_changes():
    # Multiple additions and deletions
    original = "a\nb\nc\nd\ne\n"
    modified = "a\nB\nc\nD\ne\nf\n"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output

# --- Edge Test Cases ---

def test_empty_strings():
    # Both original and modified are empty
    original = ""
    modified = ""
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output

def test_original_empty_modified_nonempty():
    # All lines are additions
    original = ""
    modified = "foo\nbar\n"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output

def test_modified_empty_original_nonempty():
    # All lines are deletions
    original = "foo\nbar\n"
    modified = ""
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output

def test_no_trailing_newline():
    # No trailing newline in original or modified
    original = "foo\nbar"
    modified = "foo\nbaz"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output

def test_mixed_line_endings():
    # Mixed \n and \r\n endings
    original = "a\r\nb\nc\r\nd"
    modified = "a\r\nB\nc\r\nd"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output

def test_single_char_difference():
    # Only one character differs
    original = "abc"
    modified = "abd"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output

def test_unicode_characters():
    # Unicode characters in lines
    original = "café\nnaïve\n"
    modified = "cafe\nnaïve\n"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output

def test_carriage_return_only():
    # Only \r as line ending
    original = "foo\rbar\r"
    modified = "foo\rbaz\r"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output

def test_no_newline_anywhere():
    # No newlines at all
    original = "foo"
    modified = "bar"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output

def test_blank_lines():
    # Blank lines in input
    original = "foo\n\nbar\n"
    modified = "foo\n\nbaz\n"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output

def test_repeated_lines():
    # Repeated lines
    original = "a\na\na\n"
    modified = "a\na\nb\n"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output

def test_trailing_blank_lines():
    # Trailing blank lines
    original = "foo\nbar\n\n"
    modified = "foo\nbar\n"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output

# --- Large Scale Test Cases ---

def test_large_identical_files():
    # Large files with identical content
    original = "\n".join(f"line {i}" for i in range(1000)) + "\n"
    modified = "\n".join(f"line {i}" for i in range(1000)) + "\n"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output

def test_large_single_line_difference():
    # Large files with a single differing line
    original = "\n".join(f"line {i}" for i in range(1000)) + "\n"
    modified_lines = [f"line {i}" for i in range(1000)]
    modified_lines[500] = "DIFFERENT LINE"
    modified = "\n".join(modified_lines) + "\n"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output

def test_large_file_addition():
    # Large file with lines added at the end
    original = "\n".join(f"line {i}" for i in range(900)) + "\n"
    modified = "\n".join(f"line {i}" for i in range(1000)) + "\n"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output
    for i in range(900, 1000):
        pass

def test_large_file_deletion():
    # Large file with lines removed from the end
    original = "\n".join(f"line {i}" for i in range(1000)) + "\n"
    modified = "\n".join(f"line {i}" for i in range(900)) + "\n"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output
    for i in range(900, 1000):
        pass

def test_large_file_all_lines_changed():
    # All lines changed
    original = "\n".join(f"foo{i}" for i in range(1000)) + "\n"
    modified = "\n".join(f"bar{i}" for i in range(1000)) + "\n"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output
    # Should contain all deletions and additions
    for i in range(1000):
        pass

def test_large_file_no_trailing_newline():
    # Large file with no trailing newline
    original = "\n".join(f"line {i}" for i in range(1000))
    modified = "\n".join(f"line {i}" for i in range(999)) + "\nDIFFERENT"
    codeflash_output = generate_unified_diff(original, modified, "a.txt", "b.txt"); diff = codeflash_output
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from codeflash.code_utils.formatter import generate_unified_diff

def test_generate_unified_diff():
    generate_unified_diff('', '\r', '', '')

To edit these changes git checkout codeflash/optimize-pr274-2025-06-04T23.10.57 and push.

[codeflash-ai]

This PR has been automatically closed because the original PR #274 by mohammedahmed18 was closed.