Find smallest number of *non-symmetric* extra context lines around each modified block

[akaihola]

Currently, Darker checks whether the AST of a .py file stays intact after applying Black changes to modified lines only. If the AST check fails, Darker will find the smallest number of extra context lines to add before (let's call that B) and after (A) each contiguous set of modified lines such that AST verification will pass.

The number of extra context lines is currently symmetric, i.e. even if e.g. skipping reformatting for the line immediately following a modified block wouldn't change the AST, it will still be reformatted if at least one line preceding the block must be reformatted to preserve the AST. In other words, A == B holds always.

What we could do after finding the smallest possible A (== B) is to keep B fixed and continue bisecting just A to find the smallest possible extra number of lines before the modified block. After that, we could do the same for B while keeping A fixed to the new value. This way we would find the smallest non-symmetric block around a modified section of the code.

[akaihola]

Or, would it be more efficient to

• first bisect and find the smallest valid B (while keeping A as ∞), and
• then bisect and find the smallest valid A (while keeping B at the value found in the first step)?

So in __main__._blacken_single_file() instead of [simplified current code]:

    max_context_lines = len(rev2_isorted.lines)
    minimum_context_lines = BinarySearch(0, max_context_lines + 1)
    while not minimum_context_lines.found:
        context_lines = minimum_context_lines.get_next()
        # (reformat with context_lines)
        if not verifier.is_equivalent_to_baseline(chosen):
            minimum_context_lines.respond(False)
        else:
            minimum_context_lines.respond(True)

we would have:

    max_context_lines = len(rev2_isorted.lines)
    minimum_context_lines_before = BinarySearch(0, max_context_lines + 1)
    while not minimum_context_lines_before.found:
        context_lines_before = minimum_context_lines_before.get_next()
        # (reformat with context_lines_before and context_lines_after=max_content_lines)
        if not verifier.is_equivalent_to_baseline(chosen):
            minimum_context_lines_before.respond(False)
        else:
            minimum_context_lines_before.respond(True)
    minimum_context_lines_after = BinarySearch(0, max_context_lines + 1 - context_lines_before)
    while not minimum_context_lines_after.found:
        context_lines_after = minimum_context_lines_after.get_next()
        # (reformat with context_lines_before and context_lines_after)
        if not verifier.is_equivalent_to_baseline(chosen):
            minimum_context_lines_after.respond(False)
        else:
            minimum_context_lines_after.respond(True)

Probably the actual reformatting part would be extracted to yet another function since it would be executed in both of the loops.