fix(rewrite): freeze walrus and starred operands too

changelog/14814.bugfix.rst

@@ -0,0 +1 @@
+Fixed assertion rewriting evaluating a walrus operator (``:=``) or a starred argument out of order when a later argument assigned to the same name, so ``assert collect(*items, identity(items := [9]))`` now passes the pre-assignment ``items``.

src/_pytest/assertion/rewrite.py

@@ -1003,19 +1003,40 @@ def visit_operand(
         """Visit an operand, freezing it against walrus operators in *later*.
 
         Operands are rewritten into statements that run in source order, but
-        a plain name is left as a bare load evaluated at the very end, when
-        the enclosing expression is assembled.  A walrus operator in a later
-        operand rebinds that name in between, so both the value used and the
-        value reported would be the post-walrus one -- Python evaluates the
-        earlier operand first.  Copy the value into a temporary instead.
+        two of them stay unhoisted and are evaluated at the very end, when the
+        enclosing expression is assembled -- after everything that follows
+        them:
+
+        * a plain name, which a walrus operator in a later operand rebinds in
+          between, so the value used and the value reported would be the
+          post-walrus one;
+        * a walrus operator itself, which would then assign in the wrong
+          order, and be visible to the operands that were meant to precede it.
+
+        Either way Python evaluates the earlier operand first, so copy it into
+        a temporary here.  A starred argument is unwrapped and rewrapped, its
+        value being subject to the same problem.
         """
         specifiers = set(self.explanation_specifiers)
         res, expl = self.visit(operand)
-        if isinstance(res, ast.Name) and res.id in _walrus_targets(later):
-            snapshot = self.assign(res)
+        value = res.value if isinstance(res, ast.Starred) else res
+        if isinstance(value, ast.NamedExpr):
+            needs_freeze = bool(later)
+        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)
+        if needs_freeze:
+            snapshot = self.assign(value)
             for key in set(self.explanation_specifiers) - specifiers:
                 self.explanation_specifiers[key] = self.display(snapshot)
-            res = snapshot
+            res = (
+                ast.copy_location(ast.Starred(snapshot, res.ctx), res)
+                if isinstance(res, ast.Starred)
+                else snapshot
+            )
         return res, expl
 
     def visit_BoolOp(self, boolop: ast.BoolOp) -> tuple[ast.Name, str]:
@@ -1141,8 +1162,6 @@ def visit_Compare(self, comp: ast.Compare) -> tuple[ast.expr, str]:
         left_res, left_expl = self.visit_operand(comp.left, comp.comparators)
         if isinstance(comp.left, ast.Compare | ast.BoolOp):
             left_expl = f"({left_expl})"
-        if isinstance(left_res, ast.NamedExpr):
-            left_res = self.assign(left_res)
         res_variables = [self.variable() for i in range(len(comp.ops))]
         load_names: list[ast.expr] = [ast.Name(v, ast.Load()) for v in res_variables]
         store_names = [ast.Name(v, ast.Store()) for v in res_variables]

testing/test_assertrewrite_coverage.py

@@ -976,6 +976,21 @@ def identity(v):
                 return "passed", value
             """)
 
+    def test_starred_argument_precedes_walrus(self) -> None:
+        assert_evaluation_order("""
+            def check():
+                def identity(v):
+                    return v
+                def collect(*values):
+                    return values
+                items = [1]
+                try:
+                    assert collect(*items, identity(items := [9])) == (1, [9])
+                except AssertionError:
+                    return "raised", items
+                return "passed", items
+            """)
+
     def test_chained_compare_operands_in_order(self) -> None:
         assert_evaluation_order("""
             def check():
@@ -989,6 +1004,21 @@ def identity(v):
                 return "passed", value
             """)
 
+    def test_bare_walrus_argument_in_order(self) -> None:
+        """A walrus argument is evaluated in place, before the ones after it."""
+        assert_evaluation_order("""
+            def check():
+                def identity(v):
+                    return v
+                def collect(*values):
+                    return values
+                try:
+                    assert collect((x := 1), identity(x := 2)) == (1, 2)
+                except AssertionError:
+                    return "raised", x
+                return "passed", x
+            """)
+
     def test_container_literal_operand_in_order(self) -> None:
         """Guard: ``generic_visit`` hoists container literals into a temporary."""
         assert_evaluation_order("""