Various improvements to enable importing stdlib module (#41)

Author: gf712

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)