Walrus expression duplicate evaluation failures with rewrite

[shuckc]

When we upgraded pytest from 7.2.0 -> 9.0.3, test failures appeared due to our use of walrus operators (:=) within assert statements. I have narrowed and reproduced this in test_walrus.py below. These two failing tests will pass if we add PYTEST_DONT_REWRITE to the docstring, or run pytest --assert=plain test_walrus.py.

"""
Minimal reproducer: pytest 9.0.3 assertion rewriting evaluates walrus operator (:=) twice.
    pytest /tmp/test_walrus.py          # FAILS
    pytest /tmp/test_walrus.py --assert=plain  # PASSES
"""

class Counter:
    def __init__(self):
        self.value = 0

    def increment(self):
        self.value += 1


def test_walrus_in_assertion_basic():
    """Walrus captures wrong value: rewriter evaluates := twice."""
    c = Counter()
    assert (before := c.value) == 0
    c.increment()
    assert before != (after := c.value)


def test_walrus_running_counter():
    """Cumulative walrus increments fire twice each → count doubles."""
    count = 0
    items = []
    items.append("a")
    assert (count := count + 1) == len(items)  # count becomes 2, not 1
    items.append("b")
    assert (count := count + 1) == len(items)  # count becomes 4, not 2
    items.append("c")
    assert (count := count + 1) == len(items)  # count becomes 6, not 3
    assert count == 3  # fails: count is 6

• a detailed description of the bug or problem you are having
• output of pip list from the virtual environment you are using
• pytest and operating system versions
• minimal example if possible

% python --version
Python 3.13.3
 % pip list
Package   Version
--------- -------
iniconfig 2.3.0
packaging 26.2
pip       25.0.1
pluggy    1.6.0
Pygments  2.20.0
pytest    9.0.3

I suspect related changes are #10758 and #11041

[shuckc]

If I use this (from claude) to emit the re-written code:

% python -c "
import ast
import _pytest.assertion.rewrite as ar
source = open('tests/test_walrus.py').read()
tree = ast.parse(source)
ar.rewrite_asserts(tree, source.encode())
print(ast.unparse(tree))
"

The output for test_walrus_in_assertion_basic includes @py_assert1 = (before := c.value) != (after := c.value) which is a re-evaluation of c.value(), after the state has changed by c.increment().

 def test_walrus_in_assertion_basic():
         """Walrus operator in assert captures wrong value after rewriting."""
         c = Counter()
         @py_assert2 = 0
         @py_assert1 = (before := c.value) == @py_assert2
         if not @py_assert1:
             @py_format4 = @pytest_ar._call_reprcompare(('==',), (@py_assert1,), ('%(py0)s == %(py3)s',), ((before := c.value), @py_assert2)) % {'py0': @pytest_ar._saferepr((before := c.value)) if 'before' in @py_builtins.locals() or
     @pytest_ar._should_repr_global_name((before := c.value)) else 'before', 'py3': @pytest_ar._saferepr(@py_assert2)}
             @py_format6 = ('' + 'assert %(py5)s') % {'py5': @py_format4}
             raise AssertionError(@pytest_ar._format_explanation(@py_format6))
         @py_assert1 = @py_assert2 = None
         c.increment()
         @py_assert1 = (before := c.value) != (after := c.value)      <<< OOPS !
         if not @py_assert1:
             @py_format3 = @pytest_ar._call_reprcompare(('!=',), (@py_assert1,), ('%(py0)s != %(py2)s',), ((before := c.value), (after := c.value))) % {'py0': @pytest_ar._saferepr((before := c.value)) if 'before' in @py_builtins.locals() or
     @pytest_ar._should_repr_global_name((before := c.value)) else 'before', 'py2': @pytest_ar._saferepr((after := c.value)) if 'after' in @py_builtins.locals() or @pytest_ar._should_repr_global_name((after := c.value)) else 'after'}
             @py_format5 = ('' + 'assert %(py4)s') % {'py4': @py_format3}
             raise AssertionError(@pytest_ar._format_explanation(@py_format5))
         @py_assert1 = None

The second test fails for the same reason, but it is less easy to see. The final straightforward comparison count == 3 is incorrectly rewritten to substitute the walrus expression that last assigned to count, which is now incorrect.

    def test_walrus_running_counter():
         ...
         @py_assert1 = @py_assert4 = None
         @py_assert2 = 3
         @py_assert1 = (count := (count + 1)) == @py_assert2         <<< OOPS !

I should mention that the contents of the AssertionError's formatted explanation is also incorrect due to re-evaluation, but that is not a serious issue for us (but it is confusing trying to debug with it).

Thanks!