Various improvements to enable importing stdlib module

integration/tests/loop_else_break_binding.py

@@ -0,0 +1,186 @@
+"""`break`/`continue` inside a loop's `else` binds to the *enclosing* loop.
+
+A loop's else clause is not part of its body, so Python binds loop control written
+there to whatever loop encloses the whole statement. The lowering used to get this
+wrong in two different ways:
+
+ * `ForLoopOpLowering` rewrote its orelse's trailing yield without checking the
+ yield's kind, so the inner loop swallowed a `break` meant for the outer one —
+ silently running every outer iteration.
+
+ * the enclosing loop's walker did claim the yield when the nested loop was a
+ `while`, but emitted the branch while that `py.while` was still unlowered,
+ producing a cross-region block reference the verifier rejects.
+
+Both are now handled by deferring: a loop refuses to lower while a nested loop
+still holds a break/continue that binds to it, so the nested loop is flattened
+into the enclosing region first and the branch is same-region by construction.
+That handshake is also why both loop patterns share one pass.
+
+Binding outwards is transitive: an else nested inside another else is still
+lexically part of whichever loop body encloses the pair, so the deferral has to
+follow the whole chain rather than stop one level in.
+"""
+
+# break in a nested for's else breaks the OUTER for.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ for inner in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Same with a while as the inner loop.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ while False:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# continue in a nested loop's else continues the OUTER loop, skipping the rest
+# of the outer body.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ while False:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ for inner in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# A while as the enclosing loop.
+log = []
+n = 0
+while n < 3:
+ n += 1
+ log.append(n)
+ for inner in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# The inner loop's own body break still binds to the inner loop, and the inner
+# else is then skipped.
+log = []
+for outer in [1, 2]:
+ for inner in [10, 20]:
+ log.append((outer, inner))
+ break
+ else:
+ log.append("inner-else-must-not-run")
+ log.append(("after", outer))
+assert log == [(1, 10), ("after", 1), (2, 10), ("after", 2)], log
+
+# Three levels: the break binds to the loop enclosing the loop whose else it is,
+# i.e. the middle one, so the outermost keeps iterating.
+log = []
+for a in [1, 2]:
+ for b in [10, 20]:
+ log.append((a, b))
+ for c in []:
+ pass
+ else:
+ break
+ log.append(("outer", a))
+assert log == [(1, 10), ("outer", 1), (2, 10), ("outer", 2)], log
+
+# An else that neither breaks nor continues still falls through to the exit.
+log = []
+for outer in [1, 2]:
+ for inner in []:
+ pass
+ else:
+ log.append(("else", outer))
+ log.append(("after", outer))
+assert log == [("else", 1), ("after", 1), ("else", 2), ("after", 2)], log
+
+# An else nested inside another else: the break binds outwards through *both*, to
+# the outermost loop. Checking only the first nested loop's else missed this and
+# silently dropped the break.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Same shape with `continue`, which must skip the rest of the outermost body.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# Same shape built from `while`s. Here the mis-binding was not silent: the branch
+# was emitted while the inner py.while was still a region of its own, which the
+# verifier rejects as a reference to a block in another region.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ while False:
+ pass
+ else:
+ while False:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Three elses deep, to check the walk follows the chain rather than a fixed depth.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ for d in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# The chain stops at the first loop *body*: this break is in the body of a loop
+# that happens to sit in an else, so it binds to that loop and no further.
+log = []
+for a in [1, 2]:
+ for b in []:
+ pass
+ else:
+ for c in [10, 20]:
+ log.append((a, c))
+ break
+ log.append(("after", a))
+assert log == [(1, 10), ("after", 1), (2, 10), ("after", 2)], log

integration/tests/unreachable_code.py

@@ -0,0 +1,98 @@
+"""Statements following a terminator in the same suite.
+
+`break`, `continue` and `return` leave the builder's insertion point in a block
+that already ends in a terminator, so MLIRGenerator used to append whatever came
+next in the suite *after* that terminator:
+
+ 'python.br_yield' op must be the last operation in the parent block
+
+The verifier rejected it, but MLIR's region DCE reached it first and segfaulted
+(deleteDeadness reading a null terminator), so the diagnostic never mattered.
+MLIRGenerator::codegen_statements now stops at the first statement that terminates the
+block, which is also what unreachable code means.
+
+Reduced from sre_parse._parse, which is why `import re` crashed during lowering.
+Nothing here asserts on the unreachable statements themselves — they cannot run;
+the point is that the module compiles and the reachable behaviour is right.
+"""
+
+
+def after_break(values):
+ seen = []
+ for v in values:
+ seen.append(v)
+ if v == 2:
+ break
+ seen.append("unreachable")
+ raise ValueError("unreachable")
+ return seen
+
+
+assert after_break([1, 2, 3]) == [1, 2], after_break([1, 2, 3])
+
+
+def after_continue(values):
+ seen = []
+ for v in values:
+ if v == 2:
+ continue
+ seen.append("unreachable")
+ seen.append(v)
+ return seen
+
+
+assert after_continue([1, 2, 3]) == [1, 3], after_continue([1, 2, 3])
+
+
+def after_return(a):
+ return a + 1
+ b = a * 2
+ raise ValueError("unreachable")
+
+
+assert after_return(1) == 2, after_return(1)
+
+
+def after_break_in_while(a):
+ n = 0
+ while True:
+ n += 1
+ if n >= a:
+ break
+ n = 999
+ raise ValueError("unreachable")
+ return n
+
+
+assert after_break_in_while(3) == 3, after_break_in_while(3)
+
+
+def after_break_in_try(values):
+ seen = []
+ for v in values:
+ try:
+ seen.append(v)
+ if v == 2:
+ break
+ raise ValueError("unreachable")
+ except ValueError:
+ seen.append("caught")
+ return seen
+
+
+assert after_break_in_try([1, 2, 3]) == [1, 2], after_break_in_try([1, 2, 3])
+
+
+def after_raise(a):
+ if a:
+ raise ValueError("boom")
+ a = 999
+ return a
+
+
+try:
+ after_raise(True)
+ raise AssertionError("should have raised")
+except ValueError as e:
+ assert str(e) == "boom", str(e)
+assert after_raise(False) is False

integration/tests/while_condition_cse.py

@@ -0,0 +1,93 @@
+"""A while condition whose value is defined outside the condition region.
+
+WhileOpLowering built the loop's test and cf.cond_br at the *condition value's*
+definition site. That is usually inside the condition region, but not always: CSE
+merges the constant behind `while True:` with an identical constant in the
+enclosing function, after which py.condition tests a value defined in the
+function's entry block. Inserting there put the cf.cond_br in the middle of that
+block, as a second terminator, and MLIR's region DCE then segfaulted on the block
+whose last operation was no longer a terminator.
+
+py.condition is by construction the terminator of the condition region's last
+block, and the value it tests necessarily dominates it, so that is where the
+branch belongs.
+
+`b = True` before the loop is what creates the constant CSE merges with — without
+it the loop's `True` is unique and the bug does not appear. Reduced from
+sre_parse._parse; the same fault was the long-standing `import weakref` crash.
+"""
+
+
+def only_exit_is_raise(a):
+ b = True
+ if a:
+ while True:
+ raise ValueError("boom")
+ return b
+
+
+try:
+ only_exit_is_raise(True)
+ raise AssertionError("should have raised")
+except ValueError as e:
+ assert str(e) == "boom", str(e)
+assert only_exit_is_raise(False) is True
+
+
+def shared_true_constant(limit):
+ flag = True
+ n = 0
+ while True:
+ n += 1
+ if n >= limit:
+ break
+ return (n, flag)
+
+
+assert shared_true_constant(3) == (3, True), shared_true_constant(3)
+
+
+def shared_false_constant(a):
+ flag = False
+ n = 0
+ while not flag:
+ n += 1
+ if n >= a:
+ flag = True
+ return n
+
+
+assert shared_false_constant(2) == 2, shared_false_constant(2)
+
+
+def condition_is_a_parameter(cond, limit):
+ # The condition value is a block argument rather than an op result, the other
+ # branch of the insertion-point choice that used to exist.
+ n = 0
+ while cond:
+ n += 1
+ if n >= limit:
+ cond = False
+ return n
+
+
+assert condition_is_a_parameter(True, 2) == 2, condition_is_a_parameter(True, 2)
+assert condition_is_a_parameter(False, 2) == 0, condition_is_a_parameter(False, 2)
+
+
+def nested_loops_sharing_true(limit):
+ t = True
+ outer = 0
+ while True:
+ outer += 1
+ inner = 0
+ while True:
+ inner += 1
+ if inner >= 2:
+ break
+ if outer >= limit:
+ break
+ return (outer, inner, t)
+
+
+assert nested_loops_sharing_true(2) == (2, 2, True), nested_loops_sharing_true(2)

integration/tests/loop_else_break_binding.py

@@ -0,0 +1,186 @@
+"""`break`/`continue` inside a loop's `else` binds to the *enclosing* loop.
+
+A loop's else clause is not part of its body, so Python binds loop control written
+there to whatever loop encloses the whole statement. The lowering used to get this
+wrong in two different ways:
+
+ * `ForLoopOpLowering` rewrote its orelse's trailing yield without checking the
+ yield's kind, so the inner loop swallowed a `break` meant for the outer one —
+ silently running every outer iteration.
+
+ * the enclosing loop's walker did claim the yield when the nested loop was a
+ `while`, but emitted the branch while that `py.while` was still unlowered,
+ producing a cross-region block reference the verifier rejects.
+
+Both are now handled by deferring: a loop refuses to lower while a nested loop
+still holds a break/continue that binds to it, so the nested loop is flattened
+into the enclosing region first and the branch is same-region by construction.
+That handshake is also why both loop patterns share one pass.
+
+Binding outwards is transitive: an else nested inside another else is still
+lexically part of whichever loop body encloses the pair, so the deferral has to
+follow the whole chain rather than stop one level in.
+"""
+
+# break in a nested for's else breaks the OUTER for.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ for inner in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Same with a while as the inner loop.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ while False:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# continue in a nested loop's else continues the OUTER loop, skipping the rest
+# of the outer body.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ while False:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ for inner in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# A while as the enclosing loop.
+log = []
+n = 0
+while n < 3:
+ n += 1
+ log.append(n)
+ for inner in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# The inner loop's own body break still binds to the inner loop, and the inner
+# else is then skipped.
+log = []
+for outer in [1, 2]:
+ for inner in [10, 20]:
+ log.append((outer, inner))
+ break
+ else:
+ log.append("inner-else-must-not-run")
+ log.append(("after", outer))
+assert log == [(1, 10), ("after", 1), (2, 10), ("after", 2)], log
+
+# Three levels: the break binds to the loop enclosing the loop whose else it is,
+# i.e. the middle one, so the outermost keeps iterating.
+log = []
+for a in [1, 2]:
+ for b in [10, 20]:
+ log.append((a, b))
+ for c in []:
+ pass
+ else:
+ break
+ log.append(("outer", a))
+assert log == [(1, 10), ("outer", 1), (2, 10), ("outer", 2)], log
+
+# An else that neither breaks nor continues still falls through to the exit.
+log = []
+for outer in [1, 2]:
+ for inner in []:
+ pass
+ else:
+ log.append(("else", outer))
+ log.append(("after", outer))
+assert log == [("else", 1), ("after", 1), ("else", 2), ("after", 2)], log
+
+# An else nested inside another else: the break binds outwards through *both*, to
+# the outermost loop. Checking only the first nested loop's else missed this and
+# silently dropped the break.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Same shape with `continue`, which must skip the rest of the outermost body.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# Same shape built from `while`s. Here the mis-binding was not silent: the branch
+# was emitted while the inner py.while was still a region of its own, which the
+# verifier rejects as a reference to a block in another region.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ while False:
+ pass
+ else:
+ while False:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Three elses deep, to check the walk follows the chain rather than a fixed depth.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ for d in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# The chain stops at the first loop *body*: this break is in the body of a loop
+# that happens to sit in an else, so it binds to that loop and no further.
+log = []
+for a in [1, 2]:
+ for b in []:
+ pass
+ else:
+ for c in [10, 20]:
+ log.append((a, c))
+ break
+ log.append(("after", a))
+assert log == [(1, 10), ("after", 1), (2, 10), ("after", 2)], log

integration/tests/unreachable_code.py

@@ -0,0 +1,98 @@
+"""Statements following a terminator in the same suite.
+
+`break`, `continue` and `return` leave the builder's insertion point in a block
+that already ends in a terminator, so MLIRGenerator used to append whatever came
+next in the suite *after* that terminator:
+
+ 'python.br_yield' op must be the last operation in the parent block
+
+The verifier rejected it, but MLIR's region DCE reached it first and segfaulted
+(deleteDeadness reading a null terminator), so the diagnostic never mattered.
+MLIRGenerator::codegen_statements now stops at the first statement that terminates the
+block, which is also what unreachable code means.
+
+Reduced from sre_parse._parse, which is why `import re` crashed during lowering.
+Nothing here asserts on the unreachable statements themselves — they cannot run;
+the point is that the module compiles and the reachable behaviour is right.
+"""
+
+
+def after_break(values):
+ seen = []
+ for v in values:
+ seen.append(v)
+ if v == 2:
+ break
+ seen.append("unreachable")
+ raise ValueError("unreachable")
+ return seen
+
+
+assert after_break([1, 2, 3]) == [1, 2], after_break([1, 2, 3])
+
+
+def after_continue(values):
+ seen = []
+ for v in values:
+ if v == 2:
+ continue
+ seen.append("unreachable")
+ seen.append(v)
+ return seen
+
+
+assert after_continue([1, 2, 3]) == [1, 3], after_continue([1, 2, 3])
+
+
+def after_return(a):
+ return a + 1
+ b = a * 2
+ raise ValueError("unreachable")
+
+
+assert after_return(1) == 2, after_return(1)
+
+
+def after_break_in_while(a):
+ n = 0
+ while True:
+ n += 1
+ if n >= a:
+ break
+ n = 999
+ raise ValueError("unreachable")
+ return n
+
+
+assert after_break_in_while(3) == 3, after_break_in_while(3)
+
+
+def after_break_in_try(values):
+ seen = []
+ for v in values:
+ try:
+ seen.append(v)
+ if v == 2:
+ break
+ raise ValueError("unreachable")
+ except ValueError:
+ seen.append("caught")
+ return seen
+
+
+assert after_break_in_try([1, 2, 3]) == [1, 2], after_break_in_try([1, 2, 3])
+
+
+def after_raise(a):
+ if a:
+ raise ValueError("boom")
+ a = 999
+ return a
+
+
+try:
+ after_raise(True)
+ raise AssertionError("should have raised")
+except ValueError as e:
+ assert str(e) == "boom", str(e)
+assert after_raise(False) is False

integration/tests/while_condition_cse.py

@@ -0,0 +1,93 @@
+"""A while condition whose value is defined outside the condition region.
+
+WhileOpLowering built the loop's test and cf.cond_br at the *condition value's*
+definition site. That is usually inside the condition region, but not always: CSE
+merges the constant behind `while True:` with an identical constant in the
+enclosing function, after which py.condition tests a value defined in the
+function's entry block. Inserting there put the cf.cond_br in the middle of that
+block, as a second terminator, and MLIR's region DCE then segfaulted on the block
+whose last operation was no longer a terminator.
+
+py.condition is by construction the terminator of the condition region's last
+block, and the value it tests necessarily dominates it, so that is where the
+branch belongs.
+
+`b = True` before the loop is what creates the constant CSE merges with — without
+it the loop's `True` is unique and the bug does not appear. Reduced from
+sre_parse._parse; the same fault was the long-standing `import weakref` crash.
+"""
+
+
+def only_exit_is_raise(a):
+ b = True
+ if a:
+ while True:
+ raise ValueError("boom")
+ return b
+
+
+try:
+ only_exit_is_raise(True)
+ raise AssertionError("should have raised")
+except ValueError as e:
+ assert str(e) == "boom", str(e)
+assert only_exit_is_raise(False) is True
+
+
+def shared_true_constant(limit):
+ flag = True
+ n = 0
+ while True:
+ n += 1
+ if n >= limit:
+ break
+ return (n, flag)
+
+
+assert shared_true_constant(3) == (3, True), shared_true_constant(3)
+
+
+def shared_false_constant(a):
+ flag = False
+ n = 0
+ while not flag:
+ n += 1
+ if n >= a:
+ flag = True
+ return n
+
+
+assert shared_false_constant(2) == 2, shared_false_constant(2)
+
+
+def condition_is_a_parameter(cond, limit):
+ # The condition value is a block argument rather than an op result, the other
+ # branch of the insertion-point choice that used to exist.
+ n = 0
+ while cond:
+ n += 1
+ if n >= limit:
+ cond = False
+ return n
+
+
+assert condition_is_a_parameter(True, 2) == 2, condition_is_a_parameter(True, 2)
+assert condition_is_a_parameter(False, 2) == 0, condition_is_a_parameter(False, 2)
+
+
+def nested_loops_sharing_true(limit):
+ t = True
+ outer = 0
+ while True:
+ outer += 1
+ inner = 0
+ while True:
+ inner += 1
+ if inner >= 2:
+ break
+ if outer >= limit:
+ break
+ return (outer, inner, t)
+
+
+assert nested_loops_sharing_true(2) == (2, 2, True), nested_loops_sharing_true(2)

integration/tests/loop_else_break_binding.py

@@ -0,0 +1,186 @@
+"""`break`/`continue` inside a loop's `else` binds to the *enclosing* loop.
+
+A loop's else clause is not part of its body, so Python binds loop control written
+there to whatever loop encloses the whole statement. The lowering used to get this
+wrong in two different ways:
+
+ * `ForLoopOpLowering` rewrote its orelse's trailing yield without checking the
+ yield's kind, so the inner loop swallowed a `break` meant for the outer one —
+ silently running every outer iteration.
+
+ * the enclosing loop's walker did claim the yield when the nested loop was a
+ `while`, but emitted the branch while that `py.while` was still unlowered,
+ producing a cross-region block reference the verifier rejects.
+
+Both are now handled by deferring: a loop refuses to lower while a nested loop
+still holds a break/continue that binds to it, so the nested loop is flattened
+into the enclosing region first and the branch is same-region by construction.
+That handshake is also why both loop patterns share one pass.
+
+Binding outwards is transitive: an else nested inside another else is still
+lexically part of whichever loop body encloses the pair, so the deferral has to
+follow the whole chain rather than stop one level in.
+"""
+
+# break in a nested for's else breaks the OUTER for.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ for inner in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Same with a while as the inner loop.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ while False:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# continue in a nested loop's else continues the OUTER loop, skipping the rest
+# of the outer body.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ while False:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ for inner in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# A while as the enclosing loop.
+log = []
+n = 0
+while n < 3:
+ n += 1
+ log.append(n)
+ for inner in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# The inner loop's own body break still binds to the inner loop, and the inner
+# else is then skipped.
+log = []
+for outer in [1, 2]:
+ for inner in [10, 20]:
+ log.append((outer, inner))
+ break
+ else:
+ log.append("inner-else-must-not-run")
+ log.append(("after", outer))
+assert log == [(1, 10), ("after", 1), (2, 10), ("after", 2)], log
+
+# Three levels: the break binds to the loop enclosing the loop whose else it is,
+# i.e. the middle one, so the outermost keeps iterating.
+log = []
+for a in [1, 2]:
+ for b in [10, 20]:
+ log.append((a, b))
+ for c in []:
+ pass
+ else:
+ break
+ log.append(("outer", a))
+assert log == [(1, 10), ("outer", 1), (2, 10), ("outer", 2)], log
+
+# An else that neither breaks nor continues still falls through to the exit.
+log = []
+for outer in [1, 2]:
+ for inner in []:
+ pass
+ else:
+ log.append(("else", outer))
+ log.append(("after", outer))
+assert log == [("else", 1), ("after", 1), ("else", 2), ("after", 2)], log
+
+# An else nested inside another else: the break binds outwards through *both*, to
+# the outermost loop. Checking only the first nested loop's else missed this and
+# silently dropped the break.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Same shape with `continue`, which must skip the rest of the outermost body.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# Same shape built from `while`s. Here the mis-binding was not silent: the branch
+# was emitted while the inner py.while was still a region of its own, which the
+# verifier rejects as a reference to a block in another region.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ while False:
+ pass
+ else:
+ while False:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Three elses deep, to check the walk follows the chain rather than a fixed depth.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ for d in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# The chain stops at the first loop *body*: this break is in the body of a loop
+# that happens to sit in an else, so it binds to that loop and no further.
+log = []
+for a in [1, 2]:
+ for b in []:
+ pass
+ else:
+ for c in [10, 20]:
+ log.append((a, c))
+ break
+ log.append(("after", a))
+assert log == [(1, 10), ("after", 1), (2, 10), ("after", 2)], log

integration/tests/unreachable_code.py

@@ -0,0 +1,98 @@
+"""Statements following a terminator in the same suite.
+
+`break`, `continue` and `return` leave the builder's insertion point in a block
+that already ends in a terminator, so MLIRGenerator used to append whatever came
+next in the suite *after* that terminator:
+
+ 'python.br_yield' op must be the last operation in the parent block
+
+The verifier rejected it, but MLIR's region DCE reached it first and segfaulted
+(deleteDeadness reading a null terminator), so the diagnostic never mattered.
+MLIRGenerator::codegen_statements now stops at the first statement that terminates the
+block, which is also what unreachable code means.
+
+Reduced from sre_parse._parse, which is why `import re` crashed during lowering.
+Nothing here asserts on the unreachable statements themselves — they cannot run;
+the point is that the module compiles and the reachable behaviour is right.
+"""
+
+
+def after_break(values):
+ seen = []
+ for v in values:
+ seen.append(v)
+ if v == 2:
+ break
+ seen.append("unreachable")
+ raise ValueError("unreachable")
+ return seen
+
+
+assert after_break([1, 2, 3]) == [1, 2], after_break([1, 2, 3])
+
+
+def after_continue(values):
+ seen = []
+ for v in values:
+ if v == 2:
+ continue
+ seen.append("unreachable")
+ seen.append(v)
+ return seen
+
+
+assert after_continue([1, 2, 3]) == [1, 3], after_continue([1, 2, 3])
+
+
+def after_return(a):
+ return a + 1
+ b = a * 2
+ raise ValueError("unreachable")
+
+
+assert after_return(1) == 2, after_return(1)
+
+
+def after_break_in_while(a):
+ n = 0
+ while True:
+ n += 1
+ if n >= a:
+ break
+ n = 999
+ raise ValueError("unreachable")
+ return n
+
+
+assert after_break_in_while(3) == 3, after_break_in_while(3)
+
+
+def after_break_in_try(values):
+ seen = []
+ for v in values:
+ try:
+ seen.append(v)
+ if v == 2:
+ break
+ raise ValueError("unreachable")
+ except ValueError:
+ seen.append("caught")
+ return seen
+
+
+assert after_break_in_try([1, 2, 3]) == [1, 2], after_break_in_try([1, 2, 3])
+
+
+def after_raise(a):
+ if a:
+ raise ValueError("boom")
+ a = 999
+ return a
+
+
+try:
+ after_raise(True)
+ raise AssertionError("should have raised")
+except ValueError as e:
+ assert str(e) == "boom", str(e)
+assert after_raise(False) is False

integration/tests/while_condition_cse.py

@@ -0,0 +1,93 @@
+"""A while condition whose value is defined outside the condition region.
+
+WhileOpLowering built the loop's test and cf.cond_br at the *condition value's*
+definition site. That is usually inside the condition region, but not always: CSE
+merges the constant behind `while True:` with an identical constant in the
+enclosing function, after which py.condition tests a value defined in the
+function's entry block. Inserting there put the cf.cond_br in the middle of that
+block, as a second terminator, and MLIR's region DCE then segfaulted on the block
+whose last operation was no longer a terminator.
+
+py.condition is by construction the terminator of the condition region's last
+block, and the value it tests necessarily dominates it, so that is where the
+branch belongs.
+
+`b = True` before the loop is what creates the constant CSE merges with — without
+it the loop's `True` is unique and the bug does not appear. Reduced from
+sre_parse._parse; the same fault was the long-standing `import weakref` crash.
+"""
+
+
+def only_exit_is_raise(a):
+ b = True
+ if a:
+ while True:
+ raise ValueError("boom")
+ return b
+
+
+try:
+ only_exit_is_raise(True)
+ raise AssertionError("should have raised")
+except ValueError as e:
+ assert str(e) == "boom", str(e)
+assert only_exit_is_raise(False) is True
+
+
+def shared_true_constant(limit):
+ flag = True
+ n = 0
+ while True:
+ n += 1
+ if n >= limit:
+ break
+ return (n, flag)
+
+
+assert shared_true_constant(3) == (3, True), shared_true_constant(3)
+
+
+def shared_false_constant(a):
+ flag = False
+ n = 0
+ while not flag:
+ n += 1
+ if n >= a:
+ flag = True
+ return n
+
+
+assert shared_false_constant(2) == 2, shared_false_constant(2)
+
+
+def condition_is_a_parameter(cond, limit):
+ # The condition value is a block argument rather than an op result, the other
+ # branch of the insertion-point choice that used to exist.
+ n = 0
+ while cond:
+ n += 1
+ if n >= limit:
+ cond = False
+ return n
+
+
+assert condition_is_a_parameter(True, 2) == 2, condition_is_a_parameter(True, 2)
+assert condition_is_a_parameter(False, 2) == 0, condition_is_a_parameter(False, 2)
+
+
+def nested_loops_sharing_true(limit):
+ t = True
+ outer = 0
+ while True:
+ outer += 1
+ inner = 0
+ while True:
+ inner += 1
+ if inner >= 2:
+ break
+ if outer >= limit:
+ break
+ return (outer, inner, t)
+
+
+assert nested_loops_sharing_true(2) == (2, 2, True), nested_loops_sharing_true(2)

integration/tests/loop_else_break_binding.py

@@ -0,0 +1,186 @@
+"""`break`/`continue` inside a loop's `else` binds to the *enclosing* loop.
+
+A loop's else clause is not part of its body, so Python binds loop control written
+there to whatever loop encloses the whole statement. The lowering used to get this
+wrong in two different ways:
+
+ * `ForLoopOpLowering` rewrote its orelse's trailing yield without checking the
+ yield's kind, so the inner loop swallowed a `break` meant for the outer one —
+ silently running every outer iteration.
+
+ * the enclosing loop's walker did claim the yield when the nested loop was a
+ `while`, but emitted the branch while that `py.while` was still unlowered,
+ producing a cross-region block reference the verifier rejects.
+
+Both are now handled by deferring: a loop refuses to lower while a nested loop
+still holds a break/continue that binds to it, so the nested loop is flattened
+into the enclosing region first and the branch is same-region by construction.
+That handshake is also why both loop patterns share one pass.
+
+Binding outwards is transitive: an else nested inside another else is still
+lexically part of whichever loop body encloses the pair, so the deferral has to
+follow the whole chain rather than stop one level in.
+"""
+
+# break in a nested for's else breaks the OUTER for.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ for inner in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Same with a while as the inner loop.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ while False:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# continue in a nested loop's else continues the OUTER loop, skipping the rest
+# of the outer body.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ while False:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ for inner in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# A while as the enclosing loop.
+log = []
+n = 0
+while n < 3:
+ n += 1
+ log.append(n)
+ for inner in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# The inner loop's own body break still binds to the inner loop, and the inner
+# else is then skipped.
+log = []
+for outer in [1, 2]:
+ for inner in [10, 20]:
+ log.append((outer, inner))
+ break
+ else:
+ log.append("inner-else-must-not-run")
+ log.append(("after", outer))
+assert log == [(1, 10), ("after", 1), (2, 10), ("after", 2)], log
+
+# Three levels: the break binds to the loop enclosing the loop whose else it is,
+# i.e. the middle one, so the outermost keeps iterating.
+log = []
+for a in [1, 2]:
+ for b in [10, 20]:
+ log.append((a, b))
+ for c in []:
+ pass
+ else:
+ break
+ log.append(("outer", a))
+assert log == [(1, 10), ("outer", 1), (2, 10), ("outer", 2)], log
+
+# An else that neither breaks nor continues still falls through to the exit.
+log = []
+for outer in [1, 2]:
+ for inner in []:
+ pass
+ else:
+ log.append(("else", outer))
+ log.append(("after", outer))
+assert log == [("else", 1), ("after", 1), ("else", 2), ("after", 2)], log
+
+# An else nested inside another else: the break binds outwards through *both*, to
+# the outermost loop. Checking only the first nested loop's else missed this and
+# silently dropped the break.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Same shape with `continue`, which must skip the rest of the outermost body.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# Same shape built from `while`s. Here the mis-binding was not silent: the branch
+# was emitted while the inner py.while was still a region of its own, which the
+# verifier rejects as a reference to a block in another region.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ while False:
+ pass
+ else:
+ while False:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Three elses deep, to check the walk follows the chain rather than a fixed depth.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ for d in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# The chain stops at the first loop *body*: this break is in the body of a loop
+# that happens to sit in an else, so it binds to that loop and no further.
+log = []
+for a in [1, 2]:
+ for b in []:
+ pass
+ else:
+ for c in [10, 20]:
+ log.append((a, c))
+ break
+ log.append(("after", a))
+assert log == [(1, 10), ("after", 1), (2, 10), ("after", 2)], log

integration/tests/unreachable_code.py

@@ -0,0 +1,98 @@
+"""Statements following a terminator in the same suite.
+
+`break`, `continue` and `return` leave the builder's insertion point in a block
+that already ends in a terminator, so MLIRGenerator used to append whatever came
+next in the suite *after* that terminator:
+
+ 'python.br_yield' op must be the last operation in the parent block
+
+The verifier rejected it, but MLIR's region DCE reached it first and segfaulted
+(deleteDeadness reading a null terminator), so the diagnostic never mattered.
+MLIRGenerator::codegen_statements now stops at the first statement that terminates the
+block, which is also what unreachable code means.
+
+Reduced from sre_parse._parse, which is why `import re` crashed during lowering.
+Nothing here asserts on the unreachable statements themselves — they cannot run;
+the point is that the module compiles and the reachable behaviour is right.
+"""
+
+
+def after_break(values):
+ seen = []
+ for v in values:
+ seen.append(v)
+ if v == 2:
+ break
+ seen.append("unreachable")
+ raise ValueError("unreachable")
+ return seen
+
+
+assert after_break([1, 2, 3]) == [1, 2], after_break([1, 2, 3])
+
+
+def after_continue(values):
+ seen = []
+ for v in values:
+ if v == 2:
+ continue
+ seen.append("unreachable")
+ seen.append(v)
+ return seen
+
+
+assert after_continue([1, 2, 3]) == [1, 3], after_continue([1, 2, 3])
+
+
+def after_return(a):
+ return a + 1
+ b = a * 2
+ raise ValueError("unreachable")
+
+
+assert after_return(1) == 2, after_return(1)
+
+
+def after_break_in_while(a):
+ n = 0
+ while True:
+ n += 1
+ if n >= a:
+ break
+ n = 999
+ raise ValueError("unreachable")
+ return n
+
+
+assert after_break_in_while(3) == 3, after_break_in_while(3)
+
+
+def after_break_in_try(values):
+ seen = []
+ for v in values:
+ try:
+ seen.append(v)
+ if v == 2:
+ break
+ raise ValueError("unreachable")
+ except ValueError:
+ seen.append("caught")
+ return seen
+
+
+assert after_break_in_try([1, 2, 3]) == [1, 2], after_break_in_try([1, 2, 3])
+
+
+def after_raise(a):
+ if a:
+ raise ValueError("boom")
+ a = 999
+ return a
+
+
+try:
+ after_raise(True)
+ raise AssertionError("should have raised")
+except ValueError as e:
+ assert str(e) == "boom", str(e)
+assert after_raise(False) is False

integration/tests/while_condition_cse.py

@@ -0,0 +1,93 @@
+"""A while condition whose value is defined outside the condition region.
+
+WhileOpLowering built the loop's test and cf.cond_br at the *condition value's*
+definition site. That is usually inside the condition region, but not always: CSE
+merges the constant behind `while True:` with an identical constant in the
+enclosing function, after which py.condition tests a value defined in the
+function's entry block. Inserting there put the cf.cond_br in the middle of that
+block, as a second terminator, and MLIR's region DCE then segfaulted on the block
+whose last operation was no longer a terminator.
+
+py.condition is by construction the terminator of the condition region's last
+block, and the value it tests necessarily dominates it, so that is where the
+branch belongs.
+
+`b = True` before the loop is what creates the constant CSE merges with — without
+it the loop's `True` is unique and the bug does not appear. Reduced from
+sre_parse._parse; the same fault was the long-standing `import weakref` crash.
+"""
+
+
+def only_exit_is_raise(a):
+ b = True
+ if a:
+ while True:
+ raise ValueError("boom")
+ return b
+
+
+try:
+ only_exit_is_raise(True)
+ raise AssertionError("should have raised")
+except ValueError as e:
+ assert str(e) == "boom", str(e)
+assert only_exit_is_raise(False) is True
+
+
+def shared_true_constant(limit):
+ flag = True
+ n = 0
+ while True:
+ n += 1
+ if n >= limit:
+ break
+ return (n, flag)
+
+
+assert shared_true_constant(3) == (3, True), shared_true_constant(3)
+
+
+def shared_false_constant(a):
+ flag = False
+ n = 0
+ while not flag:
+ n += 1
+ if n >= a:
+ flag = True
+ return n
+
+
+assert shared_false_constant(2) == 2, shared_false_constant(2)
+
+
+def condition_is_a_parameter(cond, limit):
+ # The condition value is a block argument rather than an op result, the other
+ # branch of the insertion-point choice that used to exist.
+ n = 0
+ while cond:
+ n += 1
+ if n >= limit:
+ cond = False
+ return n
+
+
+assert condition_is_a_parameter(True, 2) == 2, condition_is_a_parameter(True, 2)
+assert condition_is_a_parameter(False, 2) == 0, condition_is_a_parameter(False, 2)
+
+
+def nested_loops_sharing_true(limit):
+ t = True
+ outer = 0
+ while True:
+ outer += 1
+ inner = 0
+ while True:
+ inner += 1
+ if inner >= 2:
+ break
+ if outer >= limit:
+ break
+ return (outer, inner, t)
+
+
+assert nested_loops_sharing_true(2) == (2, 2, True), nested_loops_sharing_true(2)

integration/tests/loop_else_break_binding.py

@@ -0,0 +1,186 @@
+"""`break`/`continue` inside a loop's `else` binds to the *enclosing* loop.
+
+A loop's else clause is not part of its body, so Python binds loop control written
+there to whatever loop encloses the whole statement. The lowering used to get this
+wrong in two different ways:
+
+ * `ForLoopOpLowering` rewrote its orelse's trailing yield without checking the
+ yield's kind, so the inner loop swallowed a `break` meant for the outer one —
+ silently running every outer iteration.
+
+ * the enclosing loop's walker did claim the yield when the nested loop was a
+ `while`, but emitted the branch while that `py.while` was still unlowered,
+ producing a cross-region block reference the verifier rejects.
+
+Both are now handled by deferring: a loop refuses to lower while a nested loop
+still holds a break/continue that binds to it, so the nested loop is flattened
+into the enclosing region first and the branch is same-region by construction.
+That handshake is also why both loop patterns share one pass.
+
+Binding outwards is transitive: an else nested inside another else is still
+lexically part of whichever loop body encloses the pair, so the deferral has to
+follow the whole chain rather than stop one level in.
+"""
+
+# break in a nested for's else breaks the OUTER for.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ for inner in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Same with a while as the inner loop.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ while False:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# continue in a nested loop's else continues the OUTER loop, skipping the rest
+# of the outer body.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ while False:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ for inner in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# A while as the enclosing loop.
+log = []
+n = 0
+while n < 3:
+ n += 1
+ log.append(n)
+ for inner in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# The inner loop's own body break still binds to the inner loop, and the inner
+# else is then skipped.
+log = []
+for outer in [1, 2]:
+ for inner in [10, 20]:
+ log.append((outer, inner))
+ break
+ else:
+ log.append("inner-else-must-not-run")
+ log.append(("after", outer))
+assert log == [(1, 10), ("after", 1), (2, 10), ("after", 2)], log
+
+# Three levels: the break binds to the loop enclosing the loop whose else it is,
+# i.e. the middle one, so the outermost keeps iterating.
+log = []
+for a in [1, 2]:
+ for b in [10, 20]:
+ log.append((a, b))
+ for c in []:
+ pass
+ else:
+ break
+ log.append(("outer", a))
+assert log == [(1, 10), ("outer", 1), (2, 10), ("outer", 2)], log
+
+# An else that neither breaks nor continues still falls through to the exit.
+log = []
+for outer in [1, 2]:
+ for inner in []:
+ pass
+ else:
+ log.append(("else", outer))
+ log.append(("after", outer))
+assert log == [("else", 1), ("after", 1), ("else", 2), ("after", 2)], log
+
+# An else nested inside another else: the break binds outwards through *both*, to
+# the outermost loop. Checking only the first nested loop's else missed this and
+# silently dropped the break.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Same shape with `continue`, which must skip the rest of the outermost body.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# Same shape built from `while`s. Here the mis-binding was not silent: the branch
+# was emitted while the inner py.while was still a region of its own, which the
+# verifier rejects as a reference to a block in another region.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ while False:
+ pass
+ else:
+ while False:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Three elses deep, to check the walk follows the chain rather than a fixed depth.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ for d in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# The chain stops at the first loop *body*: this break is in the body of a loop
+# that happens to sit in an else, so it binds to that loop and no further.
+log = []
+for a in [1, 2]:
+ for b in []:
+ pass
+ else:
+ for c in [10, 20]:
+ log.append((a, c))
+ break
+ log.append(("after", a))
+assert log == [(1, 10), ("after", 1), (2, 10), ("after", 2)], log

integration/tests/unreachable_code.py

@@ -0,0 +1,98 @@
+"""Statements following a terminator in the same suite.
+
+`break`, `continue` and `return` leave the builder's insertion point in a block
+that already ends in a terminator, so MLIRGenerator used to append whatever came
+next in the suite *after* that terminator:
+
+ 'python.br_yield' op must be the last operation in the parent block
+
+The verifier rejected it, but MLIR's region DCE reached it first and segfaulted
+(deleteDeadness reading a null terminator), so the diagnostic never mattered.
+MLIRGenerator::codegen_statements now stops at the first statement that terminates the
+block, which is also what unreachable code means.
+
+Reduced from sre_parse._parse, which is why `import re` crashed during lowering.
+Nothing here asserts on the unreachable statements themselves — they cannot run;
+the point is that the module compiles and the reachable behaviour is right.
+"""
+
+
+def after_break(values):
+ seen = []
+ for v in values:
+ seen.append(v)
+ if v == 2:
+ break
+ seen.append("unreachable")
+ raise ValueError("unreachable")
+ return seen
+
+
+assert after_break([1, 2, 3]) == [1, 2], after_break([1, 2, 3])
+
+
+def after_continue(values):
+ seen = []
+ for v in values:
+ if v == 2:
+ continue
+ seen.append("unreachable")
+ seen.append(v)
+ return seen
+
+
+assert after_continue([1, 2, 3]) == [1, 3], after_continue([1, 2, 3])
+
+
+def after_return(a):
+ return a + 1
+ b = a * 2
+ raise ValueError("unreachable")
+
+
+assert after_return(1) == 2, after_return(1)
+
+
+def after_break_in_while(a):
+ n = 0
+ while True:
+ n += 1
+ if n >= a:
+ break
+ n = 999
+ raise ValueError("unreachable")
+ return n
+
+
+assert after_break_in_while(3) == 3, after_break_in_while(3)
+
+
+def after_break_in_try(values):
+ seen = []
+ for v in values:
+ try:
+ seen.append(v)
+ if v == 2:
+ break
+ raise ValueError("unreachable")
+ except ValueError:
+ seen.append("caught")
+ return seen
+
+
+assert after_break_in_try([1, 2, 3]) == [1, 2], after_break_in_try([1, 2, 3])
+
+
+def after_raise(a):
+ if a:
+ raise ValueError("boom")
+ a = 999
+ return a
+
+
+try:
+ after_raise(True)
+ raise AssertionError("should have raised")
+except ValueError as e:
+ assert str(e) == "boom", str(e)
+assert after_raise(False) is False

integration/tests/while_condition_cse.py

@@ -0,0 +1,93 @@
+"""A while condition whose value is defined outside the condition region.
+
+WhileOpLowering built the loop's test and cf.cond_br at the *condition value's*
+definition site. That is usually inside the condition region, but not always: CSE
+merges the constant behind `while True:` with an identical constant in the
+enclosing function, after which py.condition tests a value defined in the
+function's entry block. Inserting there put the cf.cond_br in the middle of that
+block, as a second terminator, and MLIR's region DCE then segfaulted on the block
+whose last operation was no longer a terminator.
+
+py.condition is by construction the terminator of the condition region's last
+block, and the value it tests necessarily dominates it, so that is where the
+branch belongs.
+
+`b = True` before the loop is what creates the constant CSE merges with — without
+it the loop's `True` is unique and the bug does not appear. Reduced from
+sre_parse._parse; the same fault was the long-standing `import weakref` crash.
+"""
+
+
+def only_exit_is_raise(a):
+ b = True
+ if a:
+ while True:
+ raise ValueError("boom")
+ return b
+
+
+try:
+ only_exit_is_raise(True)
+ raise AssertionError("should have raised")
+except ValueError as e:
+ assert str(e) == "boom", str(e)
+assert only_exit_is_raise(False) is True
+
+
+def shared_true_constant(limit):
+ flag = True
+ n = 0
+ while True:
+ n += 1
+ if n >= limit:
+ break
+ return (n, flag)
+
+
+assert shared_true_constant(3) == (3, True), shared_true_constant(3)
+
+
+def shared_false_constant(a):
+ flag = False
+ n = 0
+ while not flag:
+ n += 1
+ if n >= a:
+ flag = True
+ return n
+
+
+assert shared_false_constant(2) == 2, shared_false_constant(2)
+
+
+def condition_is_a_parameter(cond, limit):
+ # The condition value is a block argument rather than an op result, the other
+ # branch of the insertion-point choice that used to exist.
+ n = 0
+ while cond:
+ n += 1
+ if n >= limit:
+ cond = False
+ return n
+
+
+assert condition_is_a_parameter(True, 2) == 2, condition_is_a_parameter(True, 2)
+assert condition_is_a_parameter(False, 2) == 0, condition_is_a_parameter(False, 2)
+
+
+def nested_loops_sharing_true(limit):
+ t = True
+ outer = 0
+ while True:
+ outer += 1
+ inner = 0
+ while True:
+ inner += 1
+ if inner >= 2:
+ break
+ if outer >= limit:
+ break
+ return (outer, inner, t)
+
+
+assert nested_loops_sharing_true(2) == (2, 2, True), nested_loops_sharing_true(2)

integration/tests/loop_else_break_binding.py

@@ -0,0 +1,186 @@
+"""`break`/`continue` inside a loop's `else` binds to the *enclosing* loop.
+
+A loop's else clause is not part of its body, so Python binds loop control written
+there to whatever loop encloses the whole statement. The lowering used to get this
+wrong in two different ways:
+
+ * `ForLoopOpLowering` rewrote its orelse's trailing yield without checking the
+ yield's kind, so the inner loop swallowed a `break` meant for the outer one —
+ silently running every outer iteration.
+
+ * the enclosing loop's walker did claim the yield when the nested loop was a
+ `while`, but emitted the branch while that `py.while` was still unlowered,
+ producing a cross-region block reference the verifier rejects.
+
+Both are now handled by deferring: a loop refuses to lower while a nested loop
+still holds a break/continue that binds to it, so the nested loop is flattened
+into the enclosing region first and the branch is same-region by construction.
+That handshake is also why both loop patterns share one pass.
+
+Binding outwards is transitive: an else nested inside another else is still
+lexically part of whichever loop body encloses the pair, so the deferral has to
+follow the whole chain rather than stop one level in.
+"""
+
+# break in a nested for's else breaks the OUTER for.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ for inner in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Same with a while as the inner loop.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ while False:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# continue in a nested loop's else continues the OUTER loop, skipping the rest
+# of the outer body.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ while False:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ for inner in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# A while as the enclosing loop.
+log = []
+n = 0
+while n < 3:
+ n += 1
+ log.append(n)
+ for inner in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# The inner loop's own body break still binds to the inner loop, and the inner
+# else is then skipped.
+log = []
+for outer in [1, 2]:
+ for inner in [10, 20]:
+ log.append((outer, inner))
+ break
+ else:
+ log.append("inner-else-must-not-run")
+ log.append(("after", outer))
+assert log == [(1, 10), ("after", 1), (2, 10), ("after", 2)], log
+
+# Three levels: the break binds to the loop enclosing the loop whose else it is,
+# i.e. the middle one, so the outermost keeps iterating.
+log = []
+for a in [1, 2]:
+ for b in [10, 20]:
+ log.append((a, b))
+ for c in []:
+ pass
+ else:
+ break
+ log.append(("outer", a))
+assert log == [(1, 10), ("outer", 1), (2, 10), ("outer", 2)], log
+
+# An else that neither breaks nor continues still falls through to the exit.
+log = []
+for outer in [1, 2]:
+ for inner in []:
+ pass
+ else:
+ log.append(("else", outer))
+ log.append(("after", outer))
+assert log == [("else", 1), ("after", 1), ("else", 2), ("after", 2)], log
+
+# An else nested inside another else: the break binds outwards through *both*, to
+# the outermost loop. Checking only the first nested loop's else missed this and
+# silently dropped the break.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Same shape with `continue`, which must skip the rest of the outermost body.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# Same shape built from `while`s. Here the mis-binding was not silent: the branch
+# was emitted while the inner py.while was still a region of its own, which the
+# verifier rejects as a reference to a block in another region.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ while False:
+ pass
+ else:
+ while False:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Three elses deep, to check the walk follows the chain rather than a fixed depth.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ for d in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# The chain stops at the first loop *body*: this break is in the body of a loop
+# that happens to sit in an else, so it binds to that loop and no further.
+log = []
+for a in [1, 2]:
+ for b in []:
+ pass
+ else:
+ for c in [10, 20]:
+ log.append((a, c))
+ break
+ log.append(("after", a))
+assert log == [(1, 10), ("after", 1), (2, 10), ("after", 2)], log

integration/tests/unreachable_code.py

@@ -0,0 +1,98 @@
+"""Statements following a terminator in the same suite.
+
+`break`, `continue` and `return` leave the builder's insertion point in a block
+that already ends in a terminator, so MLIRGenerator used to append whatever came
+next in the suite *after* that terminator:
+
+ 'python.br_yield' op must be the last operation in the parent block
+
+The verifier rejected it, but MLIR's region DCE reached it first and segfaulted
+(deleteDeadness reading a null terminator), so the diagnostic never mattered.
+MLIRGenerator::codegen_statements now stops at the first statement that terminates the
+block, which is also what unreachable code means.
+
+Reduced from sre_parse._parse, which is why `import re` crashed during lowering.
+Nothing here asserts on the unreachable statements themselves — they cannot run;
+the point is that the module compiles and the reachable behaviour is right.
+"""
+
+
+def after_break(values):
+ seen = []
+ for v in values:
+ seen.append(v)
+ if v == 2:
+ break
+ seen.append("unreachable")
+ raise ValueError("unreachable")
+ return seen
+
+
+assert after_break([1, 2, 3]) == [1, 2], after_break([1, 2, 3])
+
+
+def after_continue(values):
+ seen = []
+ for v in values:
+ if v == 2:
+ continue
+ seen.append("unreachable")
+ seen.append(v)
+ return seen
+
+
+assert after_continue([1, 2, 3]) == [1, 3], after_continue([1, 2, 3])
+
+
+def after_return(a):
+ return a + 1
+ b = a * 2
+ raise ValueError("unreachable")
+
+
+assert after_return(1) == 2, after_return(1)
+
+
+def after_break_in_while(a):
+ n = 0
+ while True:
+ n += 1
+ if n >= a:
+ break
+ n = 999
+ raise ValueError("unreachable")
+ return n
+
+
+assert after_break_in_while(3) == 3, after_break_in_while(3)
+
+
+def after_break_in_try(values):
+ seen = []
+ for v in values:
+ try:
+ seen.append(v)
+ if v == 2:
+ break
+ raise ValueError("unreachable")
+ except ValueError:
+ seen.append("caught")
+ return seen
+
+
+assert after_break_in_try([1, 2, 3]) == [1, 2], after_break_in_try([1, 2, 3])
+
+
+def after_raise(a):
+ if a:
+ raise ValueError("boom")
+ a = 999
+ return a
+
+
+try:
+ after_raise(True)
+ raise AssertionError("should have raised")
+except ValueError as e:
+ assert str(e) == "boom", str(e)
+assert after_raise(False) is False

integration/tests/while_condition_cse.py

@@ -0,0 +1,93 @@
+"""A while condition whose value is defined outside the condition region.
+
+WhileOpLowering built the loop's test and cf.cond_br at the *condition value's*
+definition site. That is usually inside the condition region, but not always: CSE
+merges the constant behind `while True:` with an identical constant in the
+enclosing function, after which py.condition tests a value defined in the
+function's entry block. Inserting there put the cf.cond_br in the middle of that
+block, as a second terminator, and MLIR's region DCE then segfaulted on the block
+whose last operation was no longer a terminator.
+
+py.condition is by construction the terminator of the condition region's last
+block, and the value it tests necessarily dominates it, so that is where the
+branch belongs.
+
+`b = True` before the loop is what creates the constant CSE merges with — without
+it the loop's `True` is unique and the bug does not appear. Reduced from
+sre_parse._parse; the same fault was the long-standing `import weakref` crash.
+"""
+
+
+def only_exit_is_raise(a):
+ b = True
+ if a:
+ while True:
+ raise ValueError("boom")
+ return b
+
+
+try:
+ only_exit_is_raise(True)
+ raise AssertionError("should have raised")
+except ValueError as e:
+ assert str(e) == "boom", str(e)
+assert only_exit_is_raise(False) is True
+
+
+def shared_true_constant(limit):
+ flag = True
+ n = 0
+ while True:
+ n += 1
+ if n >= limit:
+ break
+ return (n, flag)
+
+
+assert shared_true_constant(3) == (3, True), shared_true_constant(3)
+
+
+def shared_false_constant(a):
+ flag = False
+ n = 0
+ while not flag:
+ n += 1
+ if n >= a:
+ flag = True
+ return n
+
+
+assert shared_false_constant(2) == 2, shared_false_constant(2)
+
+
+def condition_is_a_parameter(cond, limit):
+ # The condition value is a block argument rather than an op result, the other
+ # branch of the insertion-point choice that used to exist.
+ n = 0
+ while cond:
+ n += 1
+ if n >= limit:
+ cond = False
+ return n
+
+
+assert condition_is_a_parameter(True, 2) == 2, condition_is_a_parameter(True, 2)
+assert condition_is_a_parameter(False, 2) == 0, condition_is_a_parameter(False, 2)
+
+
+def nested_loops_sharing_true(limit):
+ t = True
+ outer = 0
+ while True:
+ outer += 1
+ inner = 0
+ while True:
+ inner += 1
+ if inner >= 2:
+ break
+ if outer >= limit:
+ break
+ return (outer, inner, t)
+
+
+assert nested_loops_sharing_true(2) == (2, 2, True), nested_loops_sharing_true(2)

integration/tests/loop_else_break_binding.py

@@ -0,0 +1,186 @@
+"""`break`/`continue` inside a loop's `else` binds to the *enclosing* loop.
+
+A loop's else clause is not part of its body, so Python binds loop control written
+there to whatever loop encloses the whole statement. The lowering used to get this
+wrong in two different ways:
+
+ * `ForLoopOpLowering` rewrote its orelse's trailing yield without checking the
+ yield's kind, so the inner loop swallowed a `break` meant for the outer one —
+ silently running every outer iteration.
+
+ * the enclosing loop's walker did claim the yield when the nested loop was a
+ `while`, but emitted the branch while that `py.while` was still unlowered,
+ producing a cross-region block reference the verifier rejects.
+
+Both are now handled by deferring: a loop refuses to lower while a nested loop
+still holds a break/continue that binds to it, so the nested loop is flattened
+into the enclosing region first and the branch is same-region by construction.
+That handshake is also why both loop patterns share one pass.
+
+Binding outwards is transitive: an else nested inside another else is still
+lexically part of whichever loop body encloses the pair, so the deferral has to
+follow the whole chain rather than stop one level in.
+"""
+
+# break in a nested for's else breaks the OUTER for.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ for inner in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Same with a while as the inner loop.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ while False:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# continue in a nested loop's else continues the OUTER loop, skipping the rest
+# of the outer body.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ while False:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ for inner in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# A while as the enclosing loop.
+log = []
+n = 0
+while n < 3:
+ n += 1
+ log.append(n)
+ for inner in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# The inner loop's own body break still binds to the inner loop, and the inner
+# else is then skipped.
+log = []
+for outer in [1, 2]:
+ for inner in [10, 20]:
+ log.append((outer, inner))
+ break
+ else:
+ log.append("inner-else-must-not-run")
+ log.append(("after", outer))
+assert log == [(1, 10), ("after", 1), (2, 10), ("after", 2)], log
+
+# Three levels: the break binds to the loop enclosing the loop whose else it is,
+# i.e. the middle one, so the outermost keeps iterating.
+log = []
+for a in [1, 2]:
+ for b in [10, 20]:
+ log.append((a, b))
+ for c in []:
+ pass
+ else:
+ break
+ log.append(("outer", a))
+assert log == [(1, 10), ("outer", 1), (2, 10), ("outer", 2)], log
+
+# An else that neither breaks nor continues still falls through to the exit.
+log = []
+for outer in [1, 2]:
+ for inner in []:
+ pass
+ else:
+ log.append(("else", outer))
+ log.append(("after", outer))
+assert log == [("else", 1), ("after", 1), ("else", 2), ("after", 2)], log
+
+# An else nested inside another else: the break binds outwards through *both*, to
+# the outermost loop. Checking only the first nested loop's else missed this and
+# silently dropped the break.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Same shape with `continue`, which must skip the rest of the outermost body.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# Same shape built from `while`s. Here the mis-binding was not silent: the branch
+# was emitted while the inner py.while was still a region of its own, which the
+# verifier rejects as a reference to a block in another region.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ while False:
+ pass
+ else:
+ while False:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Three elses deep, to check the walk follows the chain rather than a fixed depth.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ for d in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# The chain stops at the first loop *body*: this break is in the body of a loop
+# that happens to sit in an else, so it binds to that loop and no further.
+log = []
+for a in [1, 2]:
+ for b in []:
+ pass
+ else:
+ for c in [10, 20]:
+ log.append((a, c))
+ break
+ log.append(("after", a))
+assert log == [(1, 10), ("after", 1), (2, 10), ("after", 2)], log

integration/tests/unreachable_code.py

@@ -0,0 +1,98 @@
+"""Statements following a terminator in the same suite.
+
+`break`, `continue` and `return` leave the builder's insertion point in a block
+that already ends in a terminator, so MLIRGenerator used to append whatever came
+next in the suite *after* that terminator:
+
+ 'python.br_yield' op must be the last operation in the parent block
+
+The verifier rejected it, but MLIR's region DCE reached it first and segfaulted
+(deleteDeadness reading a null terminator), so the diagnostic never mattered.
+MLIRGenerator::codegen_statements now stops at the first statement that terminates the
+block, which is also what unreachable code means.
+
+Reduced from sre_parse._parse, which is why `import re` crashed during lowering.
+Nothing here asserts on the unreachable statements themselves — they cannot run;
+the point is that the module compiles and the reachable behaviour is right.
+"""
+
+
+def after_break(values):
+ seen = []
+ for v in values:
+ seen.append(v)
+ if v == 2:
+ break
+ seen.append("unreachable")
+ raise ValueError("unreachable")
+ return seen
+
+
+assert after_break([1, 2, 3]) == [1, 2], after_break([1, 2, 3])
+
+
+def after_continue(values):
+ seen = []
+ for v in values:
+ if v == 2:
+ continue
+ seen.append("unreachable")
+ seen.append(v)
+ return seen
+
+
+assert after_continue([1, 2, 3]) == [1, 3], after_continue([1, 2, 3])
+
+
+def after_return(a):
+ return a + 1
+ b = a * 2
+ raise ValueError("unreachable")
+
+
+assert after_return(1) == 2, after_return(1)
+
+
+def after_break_in_while(a):
+ n = 0
+ while True:
+ n += 1
+ if n >= a:
+ break
+ n = 999
+ raise ValueError("unreachable")
+ return n
+
+
+assert after_break_in_while(3) == 3, after_break_in_while(3)
+
+
+def after_break_in_try(values):
+ seen = []
+ for v in values:
+ try:
+ seen.append(v)
+ if v == 2:
+ break
+ raise ValueError("unreachable")
+ except ValueError:
+ seen.append("caught")
+ return seen
+
+
+assert after_break_in_try([1, 2, 3]) == [1, 2], after_break_in_try([1, 2, 3])
+
+
+def after_raise(a):
+ if a:
+ raise ValueError("boom")
+ a = 999
+ return a
+
+
+try:
+ after_raise(True)
+ raise AssertionError("should have raised")
+except ValueError as e:
+ assert str(e) == "boom", str(e)
+assert after_raise(False) is False

integration/tests/while_condition_cse.py

@@ -0,0 +1,93 @@
+"""A while condition whose value is defined outside the condition region.
+
+WhileOpLowering built the loop's test and cf.cond_br at the *condition value's*
+definition site. That is usually inside the condition region, but not always: CSE
+merges the constant behind `while True:` with an identical constant in the
+enclosing function, after which py.condition tests a value defined in the
+function's entry block. Inserting there put the cf.cond_br in the middle of that
+block, as a second terminator, and MLIR's region DCE then segfaulted on the block
+whose last operation was no longer a terminator.
+
+py.condition is by construction the terminator of the condition region's last
+block, and the value it tests necessarily dominates it, so that is where the
+branch belongs.
+
+`b = True` before the loop is what creates the constant CSE merges with — without
+it the loop's `True` is unique and the bug does not appear. Reduced from
+sre_parse._parse; the same fault was the long-standing `import weakref` crash.
+"""
+
+
+def only_exit_is_raise(a):
+ b = True
+ if a:
+ while True:
+ raise ValueError("boom")
+ return b
+
+
+try:
+ only_exit_is_raise(True)
+ raise AssertionError("should have raised")
+except ValueError as e:
+ assert str(e) == "boom", str(e)
+assert only_exit_is_raise(False) is True
+
+
+def shared_true_constant(limit):
+ flag = True
+ n = 0
+ while True:
+ n += 1
+ if n >= limit:
+ break
+ return (n, flag)
+
+
+assert shared_true_constant(3) == (3, True), shared_true_constant(3)
+
+
+def shared_false_constant(a):
+ flag = False
+ n = 0
+ while not flag:
+ n += 1
+ if n >= a:
+ flag = True
+ return n
+
+
+assert shared_false_constant(2) == 2, shared_false_constant(2)
+
+
+def condition_is_a_parameter(cond, limit):
+ # The condition value is a block argument rather than an op result, the other
+ # branch of the insertion-point choice that used to exist.
+ n = 0
+ while cond:
+ n += 1
+ if n >= limit:
+ cond = False
+ return n
+
+
+assert condition_is_a_parameter(True, 2) == 2, condition_is_a_parameter(True, 2)
+assert condition_is_a_parameter(False, 2) == 0, condition_is_a_parameter(False, 2)
+
+
+def nested_loops_sharing_true(limit):
+ t = True
+ outer = 0
+ while True:
+ outer += 1
+ inner = 0
+ while True:
+ inner += 1
+ if inner >= 2:
+ break
+ if outer >= limit:
+ break
+ return (outer, inner, t)
+
+
+assert nested_loops_sharing_true(2) == (2, 2, True), nested_loops_sharing_true(2)

integration/tests/loop_else_break_binding.py

@@ -0,0 +1,186 @@
+"""`break`/`continue` inside a loop's `else` binds to the *enclosing* loop.
+
+A loop's else clause is not part of its body, so Python binds loop control written
+there to whatever loop encloses the whole statement. The lowering used to get this
+wrong in two different ways:
+
+ * `ForLoopOpLowering` rewrote its orelse's trailing yield without checking the
+ yield's kind, so the inner loop swallowed a `break` meant for the outer one —
+ silently running every outer iteration.
+
+ * the enclosing loop's walker did claim the yield when the nested loop was a
+ `while`, but emitted the branch while that `py.while` was still unlowered,
+ producing a cross-region block reference the verifier rejects.
+
+Both are now handled by deferring: a loop refuses to lower while a nested loop
+still holds a break/continue that binds to it, so the nested loop is flattened
+into the enclosing region first and the branch is same-region by construction.
+That handshake is also why both loop patterns share one pass.
+
+Binding outwards is transitive: an else nested inside another else is still
+lexically part of whichever loop body encloses the pair, so the deferral has to
+follow the whole chain rather than stop one level in.
+"""
+
+# break in a nested for's else breaks the OUTER for.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ for inner in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Same with a while as the inner loop.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ while False:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# continue in a nested loop's else continues the OUTER loop, skipping the rest
+# of the outer body.
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ while False:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+log = []
+for outer in [1, 2, 3]:
+ log.append(outer)
+ for inner in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# A while as the enclosing loop.
+log = []
+n = 0
+while n < 3:
+ n += 1
+ log.append(n)
+ for inner in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# The inner loop's own body break still binds to the inner loop, and the inner
+# else is then skipped.
+log = []
+for outer in [1, 2]:
+ for inner in [10, 20]:
+ log.append((outer, inner))
+ break
+ else:
+ log.append("inner-else-must-not-run")
+ log.append(("after", outer))
+assert log == [(1, 10), ("after", 1), (2, 10), ("after", 2)], log
+
+# Three levels: the break binds to the loop enclosing the loop whose else it is,
+# i.e. the middle one, so the outermost keeps iterating.
+log = []
+for a in [1, 2]:
+ for b in [10, 20]:
+ log.append((a, b))
+ for c in []:
+ pass
+ else:
+ break
+ log.append(("outer", a))
+assert log == [(1, 10), ("outer", 1), (2, 10), ("outer", 2)], log
+
+# An else that neither breaks nor continues still falls through to the exit.
+log = []
+for outer in [1, 2]:
+ for inner in []:
+ pass
+ else:
+ log.append(("else", outer))
+ log.append(("after", outer))
+assert log == [("else", 1), ("after", 1), ("else", 2), ("after", 2)], log
+
+# An else nested inside another else: the break binds outwards through *both*, to
+# the outermost loop. Checking only the first nested loop's else missed this and
+# silently dropped the break.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Same shape with `continue`, which must skip the rest of the outermost body.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ continue
+ log.append("after-must-not-run")
+assert log == [1, 2, 3], log
+
+# Same shape built from `while`s. Here the mis-binding was not silent: the branch
+# was emitted while the inner py.while was still a region of its own, which the
+# verifier rejects as a reference to a block in another region.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ while False:
+ pass
+ else:
+ while False:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# Three elses deep, to check the walk follows the chain rather than a fixed depth.
+log = []
+for a in [1, 2, 3]:
+ log.append(a)
+ for b in []:
+ pass
+ else:
+ for c in []:
+ pass
+ else:
+ for d in []:
+ pass
+ else:
+ break
+assert log == [1], log
+
+# The chain stops at the first loop *body*: this break is in the body of a loop
+# that happens to sit in an else, so it binds to that loop and no further.
+log = []
+for a in [1, 2]:
+ for b in []:
+ pass
+ else:
+ for c in [10, 20]:
+ log.append((a, c))
+ break
+ log.append(("after", a))
+assert log == [(1, 10), ("after", 1), (2, 10), ("after", 2)], log

integration/tests/unreachable_code.py

@@ -0,0 +1,98 @@
+"""Statements following a terminator in the same suite.
+
+`break`, `continue` and `return` leave the builder's insertion point in a block
+that already ends in a terminator, so MLIRGenerator used to append whatever came
+next in the suite *after* that terminator:
+
+ 'python.br_yield' op must be the last operation in the parent block
+
+The verifier rejected it, but MLIR's region DCE reached it first and segfaulted
+(deleteDeadness reading a null terminator), so the diagnostic never mattered.
+MLIRGenerator::codegen_statements now stops at the first statement that terminates the
+block, which is also what unreachable code means.
+
+Reduced from sre_parse._parse, which is why `import re` crashed during lowering.
+Nothing here asserts on the unreachable statements themselves — they cannot run;
+the point is that the module compiles and the reachable behaviour is right.
+"""
+
+
+def after_break(values):
+ seen = []
+ for v in values:
+ seen.append(v)
+ if v == 2:
+ break
+ seen.append("unreachable")
+ raise ValueError("unreachable")
+ return seen
+
+
+assert after_break([1, 2, 3]) == [1, 2], after_break([1, 2, 3])
+
+
+def after_continue(values):
+ seen = []
+ for v in values:
+ if v == 2:
+ continue
+ seen.append("unreachable")
+ seen.append(v)
+ return seen
+
+
+assert after_continue([1, 2, 3]) == [1, 3], after_continue([1, 2, 3])
+
+
+def after_return(a):
+ return a + 1
+ b = a * 2
+ raise ValueError("unreachable")
+
+
+assert after_return(1) == 2, after_return(1)
+
+
+def after_break_in_while(a):
+ n = 0
+ while True:
+ n += 1
+ if n >= a:
+ break
+ n = 999
+ raise ValueError("unreachable")
+ return n
+
+
+assert after_break_in_while(3) == 3, after_break_in_while(3)
+
+
+def after_break_in_try(values):
+ seen = []
+ for v in values:
+ try:
+ seen.append(v)
+ if v == 2:
+ break
+ raise ValueError("unreachable")
+ except ValueError:
+ seen.append("caught")
+ return seen
+
+
+assert after_break_in_try([1, 2, 3]) == [1, 2], after_break_in_try([1, 2, 3])
+
+
+def after_raise(a):
+ if a:
+ raise ValueError("boom")
+ a = 999
+ return a
+
+
+try:
+ after_raise(True)
+ raise AssertionError("should have raised")
+except ValueError as e:
+ assert str(e) == "boom", str(e)
+assert after_raise(False) is False

integration/tests/while_condition_cse.py

@@ -0,0 +1,93 @@
+"""A while condition whose value is defined outside the condition region.
+
+WhileOpLowering built the loop's test and cf.cond_br at the *condition value's*
+definition site. That is usually inside the condition region, but not always: CSE
+merges the constant behind `while True:` with an identical constant in the
+enclosing function, after which py.condition tests a value defined in the
+function's entry block. Inserting there put the cf.cond_br in the middle of that
+block, as a second terminator, and MLIR's region DCE then segfaulted on the block
+whose last operation was no longer a terminator.
+
+py.condition is by construction the terminator of the condition region's last
+block, and the value it tests necessarily dominates it, so that is where the
+branch belongs.
+
+`b = True` before the loop is what creates the constant CSE merges with — without
+it the loop's `True` is unique and the bug does not appear. Reduced from
+sre_parse._parse; the same fault was the long-standing `import weakref` crash.
+"""
+
+
+def only_exit_is_raise(a):
+ b = True
+ if a:
+ while True:
+ raise ValueError("boom")
+ return b
+
+
+try:
+ only_exit_is_raise(True)
+ raise AssertionError("should have raised")
+except ValueError as e:
+ assert str(e) == "boom", str(e)
+assert only_exit_is_raise(False) is True
+
+
+def shared_true_constant(limit):
+ flag = True
+ n = 0
+ while True:
+ n += 1
+ if n >= limit:
+ break
+ return (n, flag)
+
+
+assert shared_true_constant(3) == (3, True), shared_true_constant(3)
+
+
+def shared_false_constant(a):
+ flag = False
+ n = 0
+ while not flag:
+ n += 1
+ if n >= a:
+ flag = True
+ return n
+
+
+assert shared_false_constant(2) == 2, shared_false_constant(2)
+
+
+def condition_is_a_parameter(cond, limit):
+ # The condition value is a block argument rather than an op result, the other
+ # branch of the insertion-point choice that used to exist.
+ n = 0
+ while cond:
+ n += 1
+ if n >= limit:
+ cond = False
+ return n
+
+
+assert condition_is_a_parameter(True, 2) == 2, condition_is_a_parameter(True, 2)
+assert condition_is_a_parameter(False, 2) == 0, condition_is_a_parameter(False, 2)
+
+
+def nested_loops_sharing_true(limit):
+ t = True
+ outer = 0
+ while True:
+ outer += 1
+ inner = 0
+ while True:
+ inner += 1
+ if inner >= 2:
+ break
+ if outer >= limit:
+ break
+ return (outer, inner, t)
+
+
+assert nested_loops_sharing_true(2) == (2, 2, True), nested_loops_sharing_true(2)