superacli 1.1.5 → 1.1.7

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

@@ -1,203 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-# 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

@@ -1,120 +0,0 @@
-# === 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

@@ -1,208 +0,0 @@
-# === 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

@@ -1,7 +0,0 @@
-[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

@@ -1,14 +0,0 @@
-# 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
-"""