fix(rewrite): short-circuit chained comparisons

[RonnyPfannschmidt]

Fixes #14819. Stacked on #14821 → #14817 → #14816 → #14815 → #14814 → #14447 → #14921 → #14813; its diff includes theirs.

Python evaluates a comparison chain lazily — in a < b < c, c is never evaluated when a < b is false. visit_Compare walked the comparators in a loop and only combined the results with and afterwards, by which time everything had already run:

assert 1 < 0 < 1 / 0     # ZeroDivisionError, not AssertionError
assert 1 < 0 < boom()    # boom() runs

Each link past the first now goes inside an if on the link before it — the same shape visit_BoolOp has used since #57 was fixed for and/or. Comparison chains never got the same treatment.

@py_assert1 = a < b
@py_assert2 = None
if @py_assert1:
    @py_assert2 = b < c
if not (@py_assert1 and @py_assert2):
    ...

The failure path builds a tuple of every link's result and every operand, so the temporaries belonging to links that never ran are set to None ahead of the chain rather than left unbound. None is falsey, which is also what _call_reprcompare wants: it stops at the first falsey result, and that is the link that actually failed. Messages are unchanged — assert 1 < 2 < 3 < 4 < 0 still reports assert 4 < 0.

Lands the order-chained-compare-lazy cases of the coverage matrix in #14813, as passing tests (+2). That completes the series and takes the matrix to 100 tests, none of them xfail. The two gaps nothing here fixes — introspect-container-literal and introspect-callable-variable — are recorded in #14916 on top.

[SirHegel]

Found a regression in this branch while checking my own duplicate of it against yours. A boolop in a skipped comparator raises AttributeError instead of AssertionError:

def test_boolop_or():
    a = b = 0
    assert 1 < 0 < (a or b)

E       AttributeError: 'NoneType' object has no attribute 'append'

	--assert=plain	origin/main	this branch
1 < 0 < (a or b)	AssertionError	assert 1 < 0	AttributeError
1 < 0 < (a and b)	AssertionError	assert 1 < 0	AttributeError
1 < 0 < (a or b) < 5	AssertionError	assert 1 < 0	AttributeError
1 < 0 < f()	AssertionError	assert 1 < 0	assert 1 < 0 ✓

Plain calls are fine — it is boolops specifically.

Why: visit_BoolOp builds its explanation by creating a list in the main statement body and appending to it from expl_stmts. Nesting only self.statements puts the list creation inside the if, while the appends stay outside and run unconditionally in the failure branch, against a name the skipped operand never bound:

@py_assert3 = @py_assert6 = @py_assert7 = None
@py_assert2 = @py_assert0 < @py_assert4
if @py_assert2:
    @py_assert7 = []          # <- list created here
    ...
if not (@py_assert2 and @py_assert3):
    @py_format9 = '%(py8)s' % {...}
    @py_assert7.append(@py_format9)   # <- but appended here, unconditionally

Fix — nest expl_stmts on the same condition, the way visit_BoolOp nests both:

fail_inner: list[ast.stmt] = []
fail_if = ast.If(load_names[i - 1], fail_inner, [])
fail_ifs.append((self.expl_stmts, fail_if))
self.expl_stmts.append(fail_if)
self.expl_stmts = fail_inner

Two things fall out of it, in case they save you the same detour:

• Most operands contribute nothing to the explanation, and an ast.If with an empty body is invalid — so the empty ones need dropping afterwards, innermost first, since pruning a child can empty its parent.
• Once expl_stmts is nested, @py_format names created inside can be read from the outer level. Collecting the names to pre-bind by walking the conditional blocks for Store targets picks those up; tracking self.variables by index does not, because pop_format_context only records them when the assertion_pass hook is on.

Verified on this branch: 4359 passed, 97 skipped, 14 xfailed with it applied, and the case above returns assert 1 < 0.

I opened #14918 before seeing your stack — closing it, this is yours. Happy to push the above as a commit here if that is easier than re-typing it.