Python: a checked tuple unbox without guards chooses by if expression

A lowerer that leaves the pending check to its caller (the field
dispatchers) kept the unbox inside a block value, where the if statement
choosing between the tuple and its zero lost the assignment, so a tuple
field read through a dynamic receiver was always zero.

git-bug: 382b32e109cb0ad60931124bda7305c85457aec87934d9ad59796807b537b29f

Author: darmie

crates/zyntax_python/conformance/tuple/dynamic_field_read.expected

@@ -0,0 +1,5 @@
+[(0, 0), (1, 0), (2, 0), (0, 1), (1, 1), (2, 1)]
+[[0], [10], [20], [1], [11], [21]]
+[0, 1, 2, 1, 2, 3]
+a 1 ('a', 1)
+b 2 ('b', 2)

crates/zyntax_python/conformance/tuple/dynamic_field_read.py

@@ -0,0 +1,45 @@
+# A tuple held in a field, read through a receiver whose class is not
+# known: each read yields the tuple that instance holds.
+class Node(object):
+    def __init__(self, pos, id, links):
+        self.pos = pos
+        self.id = id
+        self.links = links
+
+
+class Tag(object):
+    def __init__(self, pair):
+        self.pair = pair
+
+
+nodes = []
+for y in range(2):
+    for x in range(3):
+        nodes.append(Node((x, y), len(nodes), []))
+print([n.pos for n in nodes])
+
+by_id = len(nodes) * [None]
+for n in nodes:
+    by_id[n.id] = n
+for n in by_id:
+    (x, y) = n.pos
+    n.links.append(x * 10 + y)
+print([n.links for n in by_id])
+
+
+def positions(items):
+    out = []
+    for item in items:
+        a, b = item.pos
+        out.append(a + b)
+    return out
+
+
+print(positions(by_id))
+
+tags = [None, None]
+tags[0] = Tag(("a", 1))
+tags[1] = Tag(("b", 2))
+for t in tags:
+    name, count = t.pair
+    print(name, count, t.pair)

crates/zyntax_python/src/lower.rs

@@ -2595,7 +2595,10 @@ impl<'m> Lowerer<'m> {
             .collect();
         let value = self.tuple_of_items(items, target, span);
         // Where no check leaves the function, the caller checks after
-        // it: a read that raised yields a value nothing reads.
+        // it: a read that raised yields a value nothing reads. `pre`
+        // stays inside the block value here, so the choice is an `if`
+        // expression: an `if` statement inside a block expression does
+        // not carry its assignments past itself.
         let value = if !trusted && !self.guards {
             let is_tuple = binary(
                 BinaryOp::Ne,
@@ -2605,13 +2608,14 @@ impl<'m> Lowerer<'m> {
                 span,
             );
             let none = self.zero_of(target, span);
-            self.conditional_value(
-                is_tuple,
-                (Vec::new(), value),
-                (Vec::new(), none),
+            node(
+                TypedExpression::If(TypedIfExpr {
+                    condition: Box::new(is_tuple),
+                    then_branch: Box::new(value),
+                    else_branch: Box::new(none),
+                }),
                 target,
                 span,
-                &mut pre,
             )
         } else {
             value