superacli 1.1.4 → 1.1.6

package/ref-monty/crates/monty/test_cases/closure__pep448.py

@@ -0,0 +1,203 @@
+# Tests for PEP 448 unpacking inside closures.
+# These exercise the collect_*_from_expr helpers in prepare.rs which walk
+# expressions to find walrus-operator assignments, cell variables, and
+# referenced names in nested functions. Closures that reference variables
+# used in PEP 448 positions (dict unpack, list/tuple/set literal, call args)
+# are the only way to reach these code paths.
+
+# === Closure capturing variable used in dict unpack ===
+def outer_dict():
+    d1 = {'a': 1, 'b': 2}
+    d2 = {'c': 3}
+
+    def inner():
+        return {**d1, **d2}
+
+    return inner()
+
+
+assert outer_dict() == {'a': 1, 'b': 2, 'c': 3}, 'closure: dict unpack'
+
+
+# === Closure capturing variable used in list unpack ===
+def outer_list():
+    items = [1, 2, 3]
+    extra = [4, 5]
+
+    def inner():
+        return [*items, *extra]
+
+    return inner()
+
+
+assert outer_list() == [1, 2, 3, 4, 5], 'closure: list unpack'
+
+
+# === Closure capturing variable used in tuple unpack ===
+def outer_tuple():
+    a = (1, 2)
+    b = (3, 4)
+
+    def inner():
+        return (*a, *b)
+
+    return inner()
+
+
+assert outer_tuple() == (1, 2, 3, 4), 'closure: tuple unpack'
+
+
+# === Closure capturing variable used in set unpack ===
+def outer_set():
+    items = [1, 2, 3]
+
+    def inner():
+        return {*items}
+
+    return inner()
+
+
+assert outer_set() == {1, 2, 3}, 'closure: set unpack'
+
+
+# === Closure using PEP 448 in a function call (single * and **) ===
+def outer_call_star():
+    def f(*args, **kwargs):
+        return (args, kwargs)
+
+    args = [1, 2, 3]
+    kw = {'x': 10}
+
+    def inner():
+        return f(*args, **kw)
+
+    return inner()
+
+
+assert outer_call_star() == ((1, 2, 3), {'x': 10}), 'closure: call *args **kw'
+
+
+# === Closure using multiple * and ** in a call ===
+def outer_multi():
+    def f(*args, **kwargs):
+        return (args, kwargs)
+
+    a = [1, 2]
+    b = [3, 4]
+    kw1 = {'x': 10}
+    kw2 = {'y': 20}
+
+    def inner():
+        return f(*a, *b, **kw1, **kw2)
+
+    return inner()
+
+
+assert outer_multi() == ((1, 2, 3, 4), {'x': 10, 'y': 20}), 'closure: multi-star call'
+
+
+# === Closure calling with keyword-only args (ArgExprs::Kwargs) ===
+# The outer-function assignment `_precomp = f(a=val_a, b=val_b)` exercises
+# collect_assigned_names_from_args for the Kwargs arm.  The inner body exercises
+# collect_cell_vars_from_args and collect_referenced_names_from_args for Kwargs.
+def outer_kwargs_call():
+    def f(**kwargs):
+        return kwargs
+
+    val_a = 10
+    val_b = 20
+    # Assignment RHS is a Kwargs call → triggers collect_assigned_names_from_args Kwargs arm
+    _precomp = f(a=val_a, b=val_b)
+
+    def inner():
+        # Kwargs call in inner body → collect_cell/referenced_names Kwargs arm
+        return f(a=val_a, b=val_b)
+
+    return inner()
+
+
+assert outer_kwargs_call() == {'a': 10, 'b': 20}, 'closure: keyword-only call'
+
+
+# === Closure calling with positional + *star (ArgsKargs with args=Some) ===
+# Exercises ArgsKargs branch where the positional-args field is non-None.
+def outer_argsstar():
+    def f(*args):
+        return list(args)
+
+    pos_val = 1
+    items = [2, 3]
+    # Assignment RHS has positional arg + star → ArgsKargs with args=Some([pos_val])
+    _precomp = f(pos_val, *items)
+
+    def inner():
+        return f(pos_val, *items)
+
+    return inner()
+
+
+assert outer_argsstar() == [1, 2, 3], 'closure: positional + *args'
+
+
+# === Closure calling with named kwarg + **kw (ArgsKargs with kwargs=Some) ===
+# Exercises ArgsKargs branch where the named-kwargs field is non-None.
+def outer_kwargsstar():
+    def f(**kwargs):
+        return kwargs
+
+    val = 1
+    extra = {'b': 2}
+    # Assignment RHS has named kwarg + double-star → ArgsKargs with kwargs=Some
+    _precomp = f(a=val, **extra)
+
+    def inner():
+        return f(a=val, **extra)
+
+    return inner()
+
+
+assert outer_kwargsstar() == {'a': 1, 'b': 2}, 'closure: named kwarg + **kw'
+
+
+# === Closure with GeneralizedCall and Named kwarg ===
+# Exercises the CallKwarg::Named arm in all three collect_*_names_from_args functions.
+def outer_generalized_named():
+    def f(*args, **kwargs):
+        return (args, kwargs)
+
+    a = [1, 2]
+    b = [3]
+    key_val = 99
+    # Assignment RHS has GeneralizedCall with Named kwarg → collect_assigned_names Named arm
+    _precomp = f(*a, *b, key=key_val)
+
+    def inner():
+        # Named kwarg in GeneralizedCall → collect_cell/referenced_names Named arm
+        return f(*a, *b, key=key_val)
+
+    return inner()
+
+
+assert outer_generalized_named() == ((1, 2, 3), {'key': 99}), 'closure: generalized call with named kwarg'
+
+
+# === Closure with GeneralizedCall and plain Value arg ===
+# Exercises the CallArg::Value path of the GeneralizedCall args loop,
+# covering the Value branch of the `CallArg::Value | CallArg::Unpack` OR-pattern.
+def outer_generalized_mixed():
+    def f(*args):
+        return list(args)
+
+    const = 0
+    items1 = [1, 2]
+    items2 = [3, 4]
+    # GeneralizedCall with Value(const) + Unpack(items1) + Unpack(items2)
+    _precomp = f(const, *items1, *items2)
+
+    def inner():
+        return f(const, *items1, *items2)
+
+    return inner()
+
+
+assert outer_generalized_mixed() == [0, 1, 2, 3, 4], 'closure: generalized call with value + unpack args'

package/ref-monty/crates/monty/test_cases/closure__undefined_nonlocal.py

@@ -0,0 +1,13 @@
+# accessing nonlocal before assignment should raise NameError
+def outer():
+    def inner():
+        nonlocal x
+        return x  # x not yet defined
+
+    result = inner()
+    x = 10
+    return result
+
+
+outer()
+# Raise=NameError("cannot access free variable 'x' where it is not associated with a value in enclosing scope")

package/ref-monty/crates/monty/test_cases/compare__mixed_types.py

@@ -0,0 +1,120 @@
+# === Bool == Int equality ===
+assert True == 1, 'True == 1'
+assert False == 0, 'False == 0'
+assert 1 == True, '1 == True'
+assert 0 == False, '0 == False'
+assert True != 2, 'True != 2'
+assert False != 1, 'False != 1'
+
+# === Bool == Float equality ===
+assert True == 1.0, 'True == 1.0'
+assert False == 0.0, 'False == 0.0'
+assert 1.0 == True, '1.0 == True'
+assert 0.0 == False, '0.0 == False'
+assert True != 2.0, 'True != 2.0'
+assert 0.5 != False, '0.5 != False'
+
+# === Int == Float equality ===
+assert 5 == 5.0, '5 == 5.0'
+assert 5.0 == 5, '5.0 == 5'
+assert 5 != 5.5, '5 != 5.5'
+assert 0 == 0.0, '0 == 0.0'
+assert -3 == -3.0, '-3 == -3.0'
+
+# === Int/Float ordering ===
+assert 5 < 5.5, '5 < 5.5'
+assert 5.5 > 5, '5.5 > 5'
+assert 5 <= 5.0, '5 <= 5.0'
+assert 5.0 >= 5, '5.0 >= 5'
+assert 5 > 4.9, '5 > 4.9'
+assert 4.9 < 5, '4.9 < 5'
+
+# === Bool ordering (promotes to int) ===
+assert True > False, 'True > False'
+assert False < True, 'False < True'
+assert True >= 1, 'True >= 1'
+assert False <= 0, 'False <= 0'
+assert True > 0, 'True > 0'
+assert True < 2, 'True < 2'
+assert True > 0.5, 'True > 0.5'
+assert True < 1.5, 'True < 1.5'
+assert False < 0.5, 'False < 0.5'
+assert False >= -1, 'False >= -1'
+
+# === Cross-type non-equality ===
+assert 'hello' != 42, 'str != int'
+assert 42 != 'hello', 'int != str'
+assert b'hello' != 'hello', 'bytes != str'
+assert 'hello' != b'hello', 'str != bytes'
+assert None != 0, 'None != 0'
+assert 0 != None, '0 != None'
+assert [] != 'list', 'list != str'
+assert {} != 0, 'dict != int'
+
+# === LongInt cross-type comparisons ===
+big = 2**100
+big2 = 2**100
+assert big == big2, 'LongInt == LongInt'
+assert big != 5, 'LongInt != int'
+assert big > 5, 'LongInt > int'
+assert 5 < big, 'int < LongInt'
+assert big >= 5, 'LongInt >= int'
+assert 5 <= big, 'int <= LongInt'
+small_big = 2**100
+large_big = 2**101
+assert small_big < large_big, 'LongInt < LongInt'
+assert large_big > small_big, 'LongInt > LongInt'
+assert big != 'hello', 'LongInt != str'
+
+# === Bytes ordering ===
+assert b'abc' < b'abd', 'bytes lt'
+assert b'abc' <= b'abc', 'bytes le'
+assert b'abd' > b'abc', 'bytes gt'
+assert b'abc' >= b'abc', 'bytes ge'
+assert b'a' < b'b', 'single byte lt'
+assert b'' < b'a', 'empty bytes lt non-empty'
+
+# === String ordering ===
+assert 'abc' < 'abd', 'str lt'
+assert 'abc' <= 'abc', 'str le'
+assert 'abd' > 'abc', 'str gt'
+assert 'abc' >= 'abc', 'str ge'
+assert 'a' < 'b', 'single char lt'
+
+# === Heap-allocated string ordering (from split) ===
+parts = 'banana,apple'.split(',')
+assert parts[1] < parts[0], 'heap str lt'
+assert parts[0] > parts[1], 'heap str gt'
+assert parts[0] >= parts[0], 'heap str ge self'
+assert parts[0] <= parts[0], 'heap str le self'
+
+# === Cross-type string ordering (interned vs heap) ===
+heap_str = 'banana,apple'.split(',')[0]
+assert heap_str > 'apple', 'heap str gt interned'
+assert 'cherry' > heap_str, 'interned gt heap str'
+assert heap_str >= 'banana', 'heap str ge interned eq'
+assert 'banana' <= heap_str, 'interned le heap str eq'
+
+# === Containment: not in list ===
+assert 999 not in [1, 2, 3], 'not in list'
+assert 0 not in [1, 2, 3], 'zero not in list'
+
+# === Containment: not in tuple ===
+assert 'z' not in ('a', 'b', 'c'), 'not in tuple'
+assert 0 not in (1, 2, 3), 'zero not in tuple'
+
+# === Containment: in/not in set ===
+assert 2 in {1, 2, 3}, 'in set'
+assert 99 not in {1, 2, 3}, 'not in set'
+
+# === Containment: in/not in frozenset ===
+assert 2 in frozenset({1, 2, 3}), 'in frozenset'
+assert 99 not in frozenset({1, 2, 3}), 'not in frozenset'
+
+# === Containment: in/not in list (found) ===
+assert 2 in [1, 2, 3], 'in list'
+assert 'b' in ['a', 'b', 'c'], 'str in list'
+
+# === Containment: in/not in tuple (found) ===
+assert 'b' in ('a', 'b', 'c'), 'str in tuple'
+assert 2 in (1, 2, 3), 'int in tuple'

package/ref-monty/crates/monty/test_cases/comprehension__all.py

@@ -0,0 +1,208 @@
+# === Basic list comprehension ===
+assert [x for x in [1, 2, 3]] == [1, 2, 3], 'identity'
+assert [x * 2 for x in [1, 2, 3]] == [2, 4, 6], 'transform'
+assert [x + 1 for x in range(5)] == [1, 2, 3, 4, 5], 'range'
+
+# === With filter ===
+assert [x for x in [1, 2, 3, 4] if x > 2] == [3, 4], 'filter'
+assert [x for x in [1, 2, 3, 4, 5] if x % 2 == 0] == [2, 4], 'even filter'
+assert [x for x in range(20) if x % 2 == 0 if x % 3 == 0] == [0, 6, 12, 18], 'multi-filter'
+assert [x * 2 for x in [1, 2, 3, 4] if x > 1 if x < 4] == [4, 6], 'transform with multi-filter'
+
+# === Nested for ===
+assert [x + y for x in [1, 2] for y in [10, 20]] == [11, 21, 12, 22], 'nested'
+assert [(x, y) for x in [1, 2] for y in ['a', 'b']] == [(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')], 'nested tuple'
+assert [x * y for x in [1, 2, 3] for y in [10, 100]] == [10, 100, 20, 200, 30, 300], 'nested multiply'
+
+# === Nested with filter ===
+assert [x + y for x in [1, 2, 3] if x > 1 for y in [10, 20] if y > 10] == [22, 23], 'nested with filters'
+
+# === Set comprehension ===
+assert {x for x in [1, 2, 2, 3]} == {1, 2, 3}, 'set dedup'
+assert {x for x in [1, 2, 3] if x > 1} == {2, 3}, 'set filter'
+assert {x * 2 for x in [1, 2, 3]} == {2, 4, 6}, 'set transform'
+assert {x % 3 for x in range(10)} == {0, 1, 2}, 'set modulo'
+
+# === Dict comprehension ===
+assert {x: x * 2 for x in [1, 2, 3]} == {1: 2, 2: 4, 3: 6}, 'dict'
+assert {x: x for x in [1, 2, 3] if x > 1} == {2: 2, 3: 3}, 'dict filter'
+assert {str(x): x for x in [1, 2, 3]} == {'1': 1, '2': 2, '3': 3}, 'dict str keys'
+assert {x: y for x in [1, 2] for y in [10, 20]} == {1: 20, 2: 20}, 'dict nested overwrites'
+
+# === Scope isolation ===
+x = 'outer'
+result = [x for x in [1, 2, 3]]
+assert x == 'outer', 'loop var does not leak'
+
+y = 'before'
+result2 = [y * 2 for y in [1, 2]]
+assert y == 'before', 'loop var y does not leak'
+
+# === Access enclosing scope ===
+multiplier = 10
+assert [x * multiplier for x in [1, 2]] == [10, 20], 'closure'
+
+prefix = 'item_'
+assert [prefix + str(x) for x in [1, 2, 3]] == ['item_1', 'item_2', 'item_3'], 'closure string'
+
+base = [1, 2, 3]
+assert [x + 10 for x in base] == [11, 12, 13], 'closure list'
+
+
+# === Capture when iter uses same name as target ===
+def outer_capture_same_name():
+    x = [1, 2, 3]
+
+    def inner():
+        return [x for x in x]
+
+    return inner()
+
+
+assert outer_capture_same_name() == [1, 2, 3], 'iter uses outer x'
+
+# === Empty iterables ===
+assert [x for x in []] == [], 'empty list'
+assert {x for x in []} == set(), 'empty set'
+assert {x: x for x in []} == {}, 'empty dict'
+
+# === Filter removes all ===
+assert [x for x in [1, 2, 3] if x > 10] == [], 'filter all'
+assert {x for x in [1, 2, 3] if x > 10} == set(), 'set filter all'
+assert {x: x for x in [1, 2, 3] if x > 10} == {}, 'dict filter all'
+
+# === Complex expressions ===
+assert [x**2 for x in [1, 2, 3, 4]] == [1, 4, 9, 16], 'square'
+assert [len(s) for s in ['a', 'bb', 'ccc']] == [1, 2, 3], 'len'
+assert [[y for y in range(x)] for x in [1, 2, 3]] == [[0], [0, 1], [0, 1, 2]], 'nested comprehension'
+
+# === Nested generator referencing prior loop var ===
+# Second generator's iter references first generator's loop variable
+assert [y for x in [[1, 2], [3, 4]] for y in x] == [1, 2, 3, 4], 'flatten nested lists'
+assert [(x, y) for x in [1, 2] for y in range(x)] == [(1, 0), (2, 0), (2, 1)], 'second iter uses first var'
+
+
+def outer_nested_comp():
+    xs = [[1, 2], [3, 4]]
+
+    def inner():
+        return [y for x in xs for y in x]
+
+    return inner()
+
+
+assert outer_nested_comp() == [1, 2, 3, 4], 'nested comp in closure'
+
+# === Tuple unpacking in comprehensions ===
+pairs = [(1, 'a'), (2, 'b'), (3, 'c')]
+assert [x for x, y in pairs] == [1, 2, 3], 'unpack first element'
+assert [y for x, y in pairs] == ['a', 'b', 'c'], 'unpack second element'
+assert [str(x) + str(y) for x, y in [(1, 2), (3, 4)]] == ['12', '34'], 'unpack and use both'
+assert [(y, x) for x, y in pairs] == [('a', 1), ('b', 2), ('c', 3)], 'swap unpacked elements'
+
+# Tuple unpacking with filter
+assert [x for x, y in pairs if x > 1] == [2, 3], 'unpack with filter'
+assert [y for x, y in pairs if y != 'b'] == ['a', 'c'], 'unpack filter on second'
+
+# Triple unpacking
+triples = [(1, 2, 3), (4, 5, 6)]
+assert [a + b + c for a, b, c in triples] == [6, 15], 'triple unpack sum'
+assert [b for a, b, c in triples] == [2, 5], 'triple unpack middle'
+
+# Dict comprehension with unpacking
+d = {k: v for k, v in pairs}
+assert d == {1: 'a', 2: 'b', 3: 'c'}, 'dict comp with unpack'
+assert {v: k for k, v in pairs} == {'a': 1, 'b': 2, 'c': 3}, 'dict comp swap key/value'
+
+# Set comprehension with unpacking
+assert {x for x, y in pairs} == {1, 2, 3}, 'set comp unpack first'
+assert {y for x, y in pairs} == {'a', 'b', 'c'}, 'set comp unpack second'
+
+# Unpacking with dict.items()
+d2 = {'x': 10, 'y': 20, 'z': 30}
+assert [k for k, v in d2.items()] == ['x', 'y', 'z'], 'unpack dict items keys'
+assert [v for k, v in d2.items()] == [10, 20, 30], 'unpack dict items values'
+assert {v: k for k, v in d2.items()} == {10: 'x', 20: 'y', 30: 'z'}, 'dict comp invert dict'
+
+# Nested comprehension with unpacking
+matrix = [[(1, 2), (3, 4)], [(5, 6), (7, 8)]]
+assert [[a + b for a, b in row] for row in matrix] == [[3, 7], [11, 15]], 'nested comp unpack'
+
+# Scope isolation with unpacking (vars don't leak)
+x = 'outer_x'
+y = 'outer_y'
+result = [x + y for x, y in [(1, 2)]]
+assert x == 'outer_x', 'x does not leak from unpack'
+assert y == 'outer_y', 'y does not leak from unpack'
+
+
+# Unpacking in closure
+def outer_unpack():
+    items = [(1, 2), (3, 4)]
+
+    def inner():
+        return [a * b for a, b in items]
+
+    return inner()
+
+
+assert outer_unpack() == [2, 12], 'unpack in closure'
+
+
+# Capture variable used in unpacking pattern
+def outer_shadow_unpack():
+    x = 100
+
+    def inner():
+        # x in unpacking shadows the outer x, but we can still reference outer x in expression
+        # Actually, the x in the comprehension shadows outer x, so this tests scope isolation
+        pairs = [(1, 2), (3, 4)]
+        return [x + y for x, y in pairs]
+
+    return inner()
+
+
+assert outer_shadow_unpack() == [3, 7], 'shadow unpack in closure'
+
+# === Generator expressions (temporary: treated as list comprehensions) ===
+# TODO: When proper generators are implemented, these should return generator objects
+# instead of lists. For now, generator expressions are parsed as list comprehensions.
+# See iter__generator_expr.py for tests, and iter__generator_expr_type.py for
+# a type check test (xfail=cpython since CPython has real generators).
+
+# Generator in list() call - works identically in both Monty and CPython
+assert list(x for x in [1, 2, 3]) == [1, 2, 3], 'generator in list()'
+assert tuple(x for x in [1, 2, 3]) == (1, 2, 3), 'generator in tuple()'
+
+# Generator with condition
+assert list(x for x in range(10) if x % 2 == 0) == [0, 2, 4, 6, 8], 'generator with condition'
+
+# Nested generators
+assert list(x + y for x in range(3) for y in range(2)) == [0, 1, 1, 2, 2, 3], 'nested generator'
+
+# Generator in sum()
+assert sum(x for x in range(5)) == 10, 'generator in sum()'
+
+# Generator with unpacking
+pairs = [(1, 2), (3, 4)]
+assert list(a + b for a, b in pairs) == [3, 7], 'generator with unpacking'
+
+# list of strings join
+assert ''.join(str(x) for x in range(5)) == '01234', 'list of strings join'
+a = '1', '2', '3'
+assert ''.join(a) == '123', 'tuple of strings join'
+
+# === Regression: Iterator panic with try/except inside loop ===
+# Issue: https://github.com/pydantic/monty/issues/177
+# Verifies that exception handling in a comprehension inside a loop doesn't
+# corrupt the outer loop's iterator (causing "expected Iterator on heap" panic).
+# A prior loop is needed to potentially trigger incorrect stack depth tracking.
+for _ in range(1):
+    pass
+
+for s in ['hello']:
+    try:
+        # Inner comprehension raises exception
+        [int(c) for c in s]
+    except ValueError:
+        pass

package/ref-monty/crates/monty/test_cases/comprehension__scope.py

@@ -0,0 +1,7 @@
+[x for x in range(10)]
+
+try:
+    x
+    assert False, "Expected NameError for 'x' after comprehension"
+except NameError:
+    pass

package/ref-monty/crates/monty/test_cases/comprehension__unbound_local.py

@@ -0,0 +1,14 @@
+# Test that comprehension scoping raises UnboundLocalError when a generator's iter
+# references a later generator's loop variable (which is local but not yet assigned)
+
+z = ['outer']
+
+result = [x for x in [1] for y in z for z in [[2], [3]]]
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "comprehension__unbound_local.py", line 6, in <module>
+    result = [x for x in [1] for y in z for z in [[2], [3]]]
+                                      ~
+UnboundLocalError: cannot access local variable 'z' where it is not associated with a value
+"""