fix(rewrite): freeze walrus and starred operands too

[RonnyPfannschmidt]

Stacked on #14447 → #14921 → #14813. Its diff includes theirs.

visit_operand() (added in #14447) only froze a bare name, so two other unhoisted operands kept being evaluated after everything that follows them:

assert collect((x := 1), identity(x := 2)) == (1, 2)      # passes (1, 2) to plain Python, (2, 2) rewritten
assert collect(*items, identity(items := [9])) == (1, [9]) # passes (1, [9]) plain, (9, [9]) rewritten

A walrus operator left in place assigns only once the enclosing expression is assembled, which is after the later arguments have run — so the earlier argument saw the later assignment. A starred argument hid its value inside an ast.Starred, where the existing Name check could not reach it.

Lands the order-starred-argument case and the last order-call-argument case of the coverage matrix in #14813, as passing tests (+2).

The starred case was found by the matrix, not by hand — it is what the order-* axis is for.

[nicoddemus]

Claude found an issue here, this crashes with chained comparisons (a < b < c) because in this case value will be ast.BoolOp. Here is a test exercising the regression:

    @pytest.mark.parametrize(
        "expr",
        [
            "identity(a < b < c)",
            "(a < b < c) == True",
            "(a < b < c) + 1 == 2",
        ],
        ids=["call-arg", "compare-left", "binop-left"],
    )
    def test_chained_compare_as_operand(self, expr: str) -> None:
        """A chained comparison visits to a BoolOp, not a name; it must still rewrite."""
        assert_evaluation_order(f"""
                 def check():
                     def identity(v):
                         return v
                     a, b, c = 1, 2, 3
                     try:
                         assert {expr}
                     except AssertionError:
                         return "raised", None
                     return "passed", None
                 """)

This test crashes with:

            # Every other operand arrives as a temporary: the visit_* methods
            # hoist what they build, and generic_visit assigns whatever is left
            # -- a literal included -- so a name is all that can reach here.
>           assert isinstance(value, ast.Name), value
                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^
E           AssertionError: <ast.BoolOp object at 0x0000016EFEB6B390>

(I added the , value to the assertion for debugging).

This is the suggested change to fix it:

Suggested change

	else:
	# Every other operand arrives as a temporary: the visit_* methods
	# hoist what they build, and generic_visit assigns whatever is left
	# -- a literal included -- so a name is all that can reach here.
	assert isinstance(value, ast.Name)
	needs_freeze = value.id in _walrus_targets(later)
	elif isinstance(value, ast.Name):
	needs_freeze = value.id in _walrus_targets(later)
	else:
	# Anything else is built only from temporaries the visit_* methods
	# already hoisted -- e.g. the BoolOp a chained comparison yields --
	# so a later walrus cannot change what it evaluates to.
	needs_freeze = False

[ChihebBENCHEIKH1]

@RonnyPfannschmidt this PR fixes assert (x := 5) == (x := 6), but a rebound walrus target still shows the wrong value when it is read through an attribute.

class Page:
    def __init__(self, status):
        self.status = status

    def __repr__(self):
        return f"Page({self.status})"


def test_attribute():
    assert (p := Page(200)).status == 200 and (p := Page(404)).status == 200

On this PR (25fc1e8), on #14822 (b044239) and on main:

E       assert (200 == 200 and 404 == 200)
E        +  where 200 = Page(404).status
E        +  and   404 = Page(404).status

9.1.1 shows where 200 = Page(200).status.

• The explanation is built from the target name (rewrite.py#L985-L989). It is read after the whole assertion ran, so a later := to the same name wins.
• Copilot predicted this on fix(rewrite): prevent walrus operator double evaluation in assertions #14447 and got no reply: fix(rewrite): prevent walrus operator double evaluation in assertions #14447 (comment)
• Binding the value to a temporary where the walrus runs, (p := (@py_assert1 := Page(200))), keeps one evaluation and gives the right message. On main it fixes both cases, with two tests in TestIntrospectionWalrus.
• The patch applies cleanly on this PR and on fix(rewrite): freeze operands against any later side effect #14821, but not on fix(rewrite): short-circuit chained comparisons #14822, which rewrites the same lines.

Would you like a PR for this on top of your stack, or would you rather fold it into one of these?