superacli 1.1.4 → 1.1.6

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

@@ -0,0 +1,178 @@
+# === Construction ===
+fs = frozenset()
+assert len(fs) == 0, 'empty frozenset len'
+assert fs == frozenset(), 'empty frozenset equality'
+
+fs = frozenset([1, 2, 3])
+assert len(fs) == 3, 'frozenset from list len'
+
+# === Copy ===
+fs = frozenset([1, 2, 3])
+fs2 = fs.copy()
+assert fs == fs2, 'copy equality'
+
+# === Union ===
+fs1 = frozenset([1, 2])
+fs2 = frozenset([2, 3])
+u = fs1.union(fs2)
+assert len(u) == 3, 'union len'
+
+# === Intersection ===
+fs1 = frozenset([1, 2, 3])
+fs2 = frozenset([2, 3, 4])
+i = fs1.intersection(fs2)
+assert len(i) == 2, 'intersection len'
+
+# === Difference ===
+fs1 = frozenset([1, 2, 3])
+fs2 = frozenset([2, 3, 4])
+d = fs1.difference(fs2)
+assert len(d) == 1, 'difference len'
+
+# === Symmetric Difference ===
+fs1 = frozenset([1, 2, 3])
+fs2 = frozenset([2, 3, 4])
+sd = fs1.symmetric_difference(fs2)
+assert len(sd) == 2, 'symmetric_difference len'
+
+# === Binary operators ===
+fs = frozenset([1, 2])
+other_fs = frozenset([2, 3])
+s = {2, 3}
+
+assert fs & other_fs == frozenset([2]), 'frozenset & frozenset works'
+assert fs | other_fs == frozenset([1, 2, 3]), 'frozenset | frozenset works'
+assert fs ^ other_fs == frozenset([1, 3]), 'frozenset ^ frozenset works'
+assert fs - other_fs == frozenset([1]), 'frozenset - frozenset works'
+
+assert fs & s == frozenset([2]), 'frozenset & set works'
+assert fs | s == frozenset([1, 2, 3]), 'frozenset | set works'
+assert fs ^ s == frozenset([1, 3]), 'frozenset ^ set works'
+assert fs - s == frozenset([1]), 'frozenset - set works'
+
+keys = {'a': 1, 'b': 2}.keys()
+items = {'a': 1, 'b': 2}.items()
+assert frozenset({'a'}) & keys == frozenset({'a'}), 'frozenset & dict_keys works'
+assert frozenset({'a'}) | keys == frozenset({'a', 'b'}), 'frozenset | dict_keys works'
+assert frozenset({('a', 1)}) ^ items == frozenset({('b', 2)}), 'frozenset ^ dict_items works'
+assert frozenset({('a', 1), ('b', 2)}) - items == frozenset(), 'frozenset - dict_items works'
+
+assert type(fs | s).__name__ == 'frozenset', 'frozenset operators keep the left operand type'
+
+try:
+    fs & [1, 2]
+    assert False, 'frozenset operators reject non-set rhs'
+except TypeError as e:
+    assert str(e) == "unsupported operand type(s) for &: 'frozenset' and 'list'", (
+        'frozenset & rhs error matches CPython'
+    )
+
+# === Issubset ===
+fs1 = frozenset([1, 2])
+fs2 = frozenset([1, 2, 3])
+assert fs1.issubset(fs2) == True, 'issubset true'
+assert fs2.issubset(fs1) == False, 'issubset false'
+
+# === Issuperset ===
+fs1 = frozenset([1, 2, 3])
+fs2 = frozenset([1, 2])
+assert fs1.issuperset(fs2) == True, 'issuperset true'
+assert fs2.issuperset(fs1) == False, 'issuperset false'
+
+# === Isdisjoint ===
+fs1 = frozenset([1, 2])
+fs2 = frozenset([3, 4])
+fs3 = frozenset([2, 3])
+assert fs1.isdisjoint(fs2) == True, 'isdisjoint true'
+assert fs1.isdisjoint(fs3) == False, 'isdisjoint false'
+
+# === Bool ===
+assert bool(frozenset()) == False, 'empty frozenset is falsy'
+assert bool(frozenset([1])) == True, 'non-empty frozenset is truthy'
+
+# === repr ===
+assert repr(frozenset()) == 'frozenset()', 'empty frozenset repr'
+
+# === Hashing ===
+fs = frozenset([1, 2, 3])
+h = hash(fs)
+assert isinstance(h, int), 'frozenset hash is int'
+
+# Same elements should have same hash
+fs1 = frozenset([1, 2, 3])
+fs2 = frozenset([3, 2, 1])  # Different order
+assert hash(fs1) == hash(fs2), 'frozenset hash is order-independent'
+
+# === As dict key ===
+d = {}
+fs = frozenset([1, 2])
+d[fs] = 'value'
+assert d[fs] == 'value', 'frozenset as dict key'
+assert d[frozenset([2, 1])] == 'value', 'frozenset key lookup order-independent'
+
+# === Construction from various iterables ===
+fs = frozenset('abc')
+assert len(fs) == 3, 'frozenset from string len'
+assert 'a' in fs and 'b' in fs and 'c' in fs, 'frozenset from string elements'
+
+fs = frozenset((1, 2, 3))
+assert fs == frozenset({1, 2, 3}), 'frozenset from tuple'
+
+fs = frozenset(range(5))
+assert fs == frozenset({0, 1, 2, 3, 4}), 'frozenset from range'
+
+fs = frozenset({1, 2, 3})
+assert len(fs) == 3, 'frozenset from set'
+
+# === Containment (in / not in) ===
+fs = frozenset({1, 2, 3})
+assert 1 in fs, 'in frozenset positive'
+assert 4 not in fs, 'not in frozenset'
+assert 'x' not in frozenset({'a', 'b'}), 'not in frozenset strings'
+
+# === Iteration ===
+result = []
+for x in frozenset({1, 2, 3}):
+    result.append(x)
+assert len(result) == 3, 'frozenset iteration length'
+assert set(result) == {1, 2, 3}, 'frozenset iteration elements'
+
+result = []
+for x in frozenset():
+    result.append(x)
+assert result == [], 'empty frozenset iteration'
+
+# === Inequality (!=) ===
+assert frozenset({1, 2}) != frozenset({1, 3}), 'frozenset ne different'
+assert not (frozenset({1, 2}) != frozenset({1, 2})), 'frozenset ne same'
+
+# === Methods accepting iterables ===
+assert frozenset({1, 2}).union([3, 4]) == frozenset({1, 2, 3, 4}), 'union with list arg'
+assert frozenset({1, 2, 3}).intersection([2, 3, 4]) == frozenset({2, 3}), 'intersection with list arg'
+assert frozenset({1, 2, 3}).difference([2]) == frozenset({1, 3}), 'difference with list arg'
+assert frozenset({1, 2}).symmetric_difference([2, 3]) == frozenset({1, 3}), 'symmetric_difference with list arg'
+assert frozenset({1}).union(range(3)) == frozenset({0, 1, 2}), 'union with range arg'
+assert frozenset({1}).union((2, 3)) == frozenset({1, 2, 3}), 'union with tuple arg'
+
+# === issubset/issuperset/isdisjoint with non-set iterables ===
+fs = frozenset({1, 2, 3})
+assert fs.issubset(range(10)), 'issubset with range'
+assert fs.issuperset([1, 2]), 'issuperset with list'
+assert fs.isdisjoint([4, 5, 6]), 'isdisjoint with list'
+assert not fs.isdisjoint([3, 4]), 'not isdisjoint with list'
+
+# === Different hashes for different frozensets ===
+fs1 = frozenset({1, 2})
+fs2 = frozenset({3, 4})
+# Not guaranteed to be different, but very likely
+# Instead just verify they're integers and stable
+assert hash(fs1) == hash(frozenset({2, 1})), 'hash stable across order'
+assert hash(frozenset()) == hash(frozenset()), 'empty frozenset hash stable'
+
+# === Frozenset as set element ===
+s = {frozenset({1, 2}), frozenset({3, 4})}
+assert len(s) == 2, 'set of frozensets'
+assert frozenset({1, 2}) in s, 'frozenset element lookup'
+# Duplicate frozenset should dedup
+s2 = {frozenset({1}), frozenset({1})}
+assert len(s2) == 1, 'duplicate frozensets dedup in set'

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

@@ -0,0 +1,236 @@
+# === Basic f-strings ===
+assert f'hello' == 'hello', 'basic f-string'
+assert f'' == '', 'empty f-string'
+
+# === Simple interpolation ===
+x = 'world'
+assert f'hello {x}' == 'hello world', 'simple interpolation'
+
+# multiple interpolations
+a = 1
+b = 2
+assert f'{a} + {b} = {a + b}' == '1 + 2 = 3', 'multiple interpolations'
+
+# expression in f-string
+assert f'{1 + 2 + 3}' == '6', 'expression'
+
+# === Value types ===
+# list value
+x = [1, 2, 3]
+assert f'list: {x}' == 'list: [1, 2, 3]', 'list value'
+
+# bool value
+x = True
+assert f'value: {x}' == 'value: True', 'bool value'
+
+# int value
+assert f'{42}' == '42', 'int value'
+
+# float value
+assert f'{3.14}' == '3.14', 'float value'
+
+# None value
+assert f'{None}' == 'None', 'None value'
+
+# === Conversion flags (!s, !r, !a) ===
+# conversion !s (str)
+assert f'{42!s}' == '42', 'conversion !s'
+
+# conversion !r (repr)
+assert f'{"hello"!r}' == "'hello'", 'conversion !r'
+
+# conversion !r on int (should be same as str for int)
+assert f'{42!r}' == '42', 'conversion !r on int'
+
+# conversion !r on list
+assert f'{[1, 2]!r}' == '[1, 2]', 'conversion !r on list'
+
+# conversion !s on string (no quotes)
+assert f'{"hello"!s}' == 'hello', 'conversion !s on string'
+
+# conversion !a (ascii) - escapes non-ASCII characters
+assert f'{"café"!a}' == "'caf\\xe9'", 'conversion !a'
+assert f'{"hello"!a}' == "'hello'", 'conversion !a ascii only'
+assert f'{"日本"!a}' == "'\\u65e5\\u672c'", 'conversion !a unicode'
+
+# === String padding and alignment ===
+# format spec: width (left-aligned by default for strings)
+assert f'{"hi":10}' == 'hi        ', 'format width'
+
+# format spec: left align
+assert f'{"hi":<10}' == 'hi        ', 'format left align'
+
+# format spec: right align
+assert f'{"hi":>10}' == '        hi', 'format right align'
+
+# format spec: center align
+assert f'{"hi":^10}' == '    hi    ', 'format center align'
+
+# center align with odd padding
+assert f'{"zip":^6}' == ' zip  ', 'format center align odd'
+
+# format spec: fill character
+assert f'{"hi":*>10}' == '********hi', 'format fill right'
+assert f'{"hi":_<10}' == 'hi________', 'format fill left'
+assert f'{"hi":*^10}' == '****hi****', 'format fill center'
+
+# string truncation with precision
+assert f'{"xylophone":.5}' == 'xylop', 'string truncation'
+assert f'{"xylophone":10.5}' == 'xylop     ', 'string truncation with width'
+
+# === Integer formatting ===
+# basic integer
+assert f'{42}' == '42', 'basic integer'
+
+# integer with :d type
+assert f'{42:d}' == '42', 'integer :d'
+
+# integer padding
+assert f'{42:4d}' == '  42', 'integer padding'
+assert f'{42:04d}' == '0042', 'integer zero padding'
+
+# integer with sign
+assert f'{42:+d}' == '+42', 'integer positive sign'
+assert f'{42: d}' == ' 42', 'integer space for positive'
+assert f'{-42:+d}' == '-42', 'integer negative with sign'
+assert f'{-42: d}' == '-42', 'integer negative space'
+
+# sign-aware padding
+assert f'{-23:=5d}' == '-  23', 'sign-aware padding'
+
+# === Float formatting ===
+# basic float
+assert f'{3.14159}' == '3.14159', 'basic float'
+
+# float with :f type
+assert f'{3.141592653589793:f}' == '3.141593', 'float :f'
+
+# float precision
+assert f'{3.141592653589793:.2f}' == '3.14', 'float precision'
+assert f'{3.141592653589793:.4f}' == '3.1416', 'float precision 4'
+
+# float width and precision
+assert f'{3.141592653589793:06.2f}' == '003.14', 'float zero pad with precision'
+assert f'{3.141592653589793:10.2f}' == '      3.14', 'float width with precision'
+
+# float with sign
+assert f'{3.14:+.2f}' == '+3.14', 'float positive sign'
+assert f'{-3.14:+.2f}' == '-3.14', 'float negative with sign'
+assert f'{3.14:-.2f}' == '3.14', 'float explicit minus sign'
+assert f'{-3.14:-.2f}' == '-3.14', 'float explicit minus sign negative'
+
+# exponential notation
+assert f'{1234.5678:e}' == '1.234568e+03', 'exponential lowercase'
+assert f'{1234.5678:E}' == '1.234568E+03', 'exponential uppercase'
+assert f'{1234.5678:.2e}' == '1.23e+03', 'exponential with precision'
+assert f'{0.00012345:.2e}' == '1.23e-04', 'exponential small number'
+
+# general format (g/G) - uses exponential for very large/small numbers
+assert f'{1.5:g}' == '1.5', 'general format simple'
+assert f'{1.500:g}' == '1.5', 'general format strips trailing zeros'
+assert f'{1234567890:g}' == '1.23457e+09', 'general format large number'
+
+# percentage
+assert f'{0.25:%}' == '25.000000%', 'percentage default precision'
+assert f'{0.25:.1%}' == '25.0%', 'percentage with precision'
+assert f'{0.125:.0%}' == '12%', 'percentage zero precision'
+
+# === Nested format specs ===
+width = 10
+assert f'{"hi":{width}}' == 'hi        ', 'nested format spec width'
+
+# nested alignment and width
+align = '^'
+assert f'{"test":{align}{width}}' == '   test   ', 'nested align and width'
+
+# nested precision
+prec = 3
+assert f'{"xylophone":.{prec}}' == 'xyl', 'nested precision'
+
+
+# === f-string in function ===
+def greet(name):
+    return f'Hello, {name}!'
+
+
+assert greet('World') == 'Hello, World!', 'f-string in function'
+
+
+# function returning formatted value
+def format_num(n, w):
+    return f'{n:>{w}}'
+
+
+assert format_num('x', 5) == '    x', 'f-string with params'
+
+# === Escaping ===
+# double braces to escape
+assert f'{{}}' == '{}', 'escaped braces'
+assert f'{{x}}' == '{x}', 'escaped braces with content'
+assert f'{{{42}}}' == '{42}', 'value inside escaped braces'
+
+# === Complex expressions ===
+# TODO: method call on literal - parser doesn't support this yet
+# assert f'{"hello".upper()}' == 'HELLO', 'method call on literal'
+
+# TODO: method call on variable - str.upper() not implemented yet
+# s = 'hello'
+# assert f'{s.upper()}' == 'HELLO', 'method call on variable'
+
+# subscript in f-string
+lst = [10, 20, 30]
+assert f'{lst[1]}' == '20', 'subscript'
+
+# dict lookup
+d = {'a': 1, 'b': 2}
+assert f'{d["a"]}' == '1', 'dict lookup'
+
+# TODO: conditional expression - parser doesn't support IfExp yet
+# x = 5
+# assert f'{x if x > 0 else -x}' == '5', 'conditional positive'
+# x = -5
+# assert f'{-x if x < 0 else x}' == '5', 'conditional negative'
+
+# === String concatenation ===
+name = 'world'
+# regular string + f-string (implicit concatenation)
+assert f'hello {name}' == 'hello world', 'str concat with fstring'
+
+# === Empty interpolation expression ===
+# (this should be a syntax error, but test current behavior)
+# assert f'{}' would be syntax error
+
+# === Whitespace in format spec ===
+# no extra whitespace handling needed, width handles it
+assert f'{"x":5}' == 'x    ', 'single char width'
+
+# === Unicode character counting in padding ===
+x = 'café'
+assert f'{x:_<10}' == 'café______'
+assert f'{x:_>10}' == '______café'
+assert f'{x:_^10}' == '___café___'
+assert f'{x:_^11}' == '___café____'
+assert f'{x:é<10}' == 'cafééééééé'
+assert f'{x:é>10}' == 'éééééécafé'
+assert f'{x:é^10}' == 'ééécaféééé'
+assert f'{x:é^11}' == 'ééécafééééé'
+
+# === Conversion flag with type spec ===
+# conversion flag produces string, so 's' format should work
+assert f'{42!r:s}' == '42', 'conversion with type spec'
+
+# === Zero-padding with negative numbers ===
+# zero-padding should use sign-aware alignment
+x = -42
+assert f'{x:05d}' == '-0042', 'zero pad negative'
+
+# === Debug/self-documenting expressions (=) ===
+a = 42
+assert f'{a=}' == 'a=42', 'basic debug expression'
+assert f'{a = }' == 'a = 42', 'debug with spaces'
+name = 'test'
+assert f'{name=}' == "name='test'", 'debug uses repr for strings'
+assert f'{name = }' == "name = 'test'", 'debug uses repr for strings'
+assert f'{name=!s}' == 'name=test', 'debug with !s conversion'
+assert f'{name=!r}' == "name='test'", 'debug with !r conversion'
+assert f'{1+1=}' == '1+1=2', 'debug with expression'

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

@@ -0,0 +1,3 @@
+# '=' alignment on string raises ValueError
+f'{"hello":=10}'
+# Raise=ValueError("'=' alignment not allowed in string format specifier")

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

@@ -0,0 +1,3 @@
+# float format specifier ':f' on string raises ValueError
+f'{"hello":f}'
+# Raise=ValueError("Unknown format code 'f' for object of type 'str'")

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

@@ -0,0 +1,3 @@
+# integer format specifier ':d' on float raises ValueError
+f'{3.14:d}'
+# Raise=ValueError("Unknown format code 'd' for object of type 'float'")

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

@@ -0,0 +1,3 @@
+# integer format specifier ':d' on string raises ValueError
+f'{"hello":d}'
+# Raise=ValueError("Unknown format code 'd' for object of type 'str'")

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

@@ -0,0 +1,4 @@
+# xfail=cpython
+# invalid format specifier with trailing characters (detected at parse time)
+f'{1:10xyz}'
+# Raise=SyntaxError("Invalid format specifier '10xyz'")

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

@@ -0,0 +1,4 @@
+# invalid format specifier with dynamic spec
+spec = 'xyz'
+f'{1:{spec}}'
+# Raise=ValueError("Invalid format specifier 'xyz' for object of type 'int'")

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

@@ -0,0 +1,4 @@
+# xfail=cpython
+# invalid format specifier for string (detected at parse time)
+f'{"hello":abc}'
+# Raise=SyntaxError("Invalid format specifier 'abc'")

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

@@ -0,0 +1,3 @@
+# string format specifier ':s' on integer raises ValueError
+f'{42:s}'
+# Raise=ValueError("Unknown format code 's' for object of type 'int'")

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

@@ -0,0 +1,6 @@
+def f(**kwargs):
+    pass
+
+
+f(**{'x': 1}, **{'x': 2})
+# Raise=TypeError("f() got multiple values for keyword argument 'x'")

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

@@ -0,0 +1,42 @@
+def f(*args, **kwargs):
+    return args, kwargs
+
+
+# === Multiple *args ===
+assert f(*[1, 2], *[3, 4]) == ((1, 2, 3, 4), {}), 'multiple star args'
+assert f(0, *[1, 2], 3) == ((0, 1, 2, 3), {}), 'positional after star args'
+assert f(*[], *[1]) == ((1,), {}), 'unpack empty then non-empty'
+
+# === Multiple **kwargs ===
+assert f(**{'a': 1}, **{'b': 2}) == ((), {'a': 1, 'b': 2}), 'multiple star-star kwargs'
+assert f(**{'a': 1}, b=2) == ((), {'a': 1, 'b': 2}), 'named after star-star'
+assert f(key='before', **{'a': 1}) == ((), {'key': 'before', 'a': 1}), 'named before star-star'
+
+# === Mixed ===
+assert f(1, *[2, 3], **{'x': 4}) == ((1, 2, 3), {'x': 4}), 'mixed star and star-star'
+
+# === Builtin callable with GeneralizedCall (Callable::Builtin path) ===
+# max(*[1,2], *[3,4]) exercises the Callable::Builtin branch in compile_call GeneralizedCall
+result = max(*[1, 2], *[3, 4])
+assert result == 4, 'builtin max with multiple *args'
+
+result = min(*[5, 3], *[7, 1])
+assert result == 1, 'builtin min with multiple *args'
+
+# === Expression-based callable with GeneralizedCall (compile_call_args path) ===
+# funcs[0](*[1,2], *[3,4]) exercises the GeneralizedCall branch in compile_call_args
+funcs = [f]
+result = funcs[0](*[1, 2], *[3, 4])
+assert result == ((1, 2, 3, 4), {}), 'subscript call with multiple *args'
+
+result = funcs[0](**{'a': 1}, **{'b': 2})
+assert result == ((), {'a': 1, 'b': 2}), 'subscript call with multiple **kwargs'
+
+# === Named kwarg in GeneralizedCall (compile_generalized_call_body Named path) ===
+# f(*[1,2], *[3], x=5): two *unpacks → GeneralizedCall; x=5 is a Named kwarg.
+# This exercises the CallKwarg::Named arm in compile_generalized_call_body.
+result = f(*[1, 2], *[3], x=5)
+assert result == ((1, 2, 3), {'x': 5}), 'named kwarg in multi-star GeneralizedCall'
+
+result = funcs[0](*[1, 2], *[3], x=5)
+assert result == ((1, 2, 3), {'x': 5}), 'subscript call: named kwarg in GeneralizedCall'

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

@@ -0,0 +1,117 @@
+# Tests for default parameter values in function definitions
+
+# === Basic default values ===
+def f_basic(a, b=10):
+    return a + b
+
+
+assert f_basic(1) == 11, 'default used'
+assert f_basic(1, 2) == 3, 'default overridden'
+assert f_basic(5) == 15, 'default used again'
+
+
+# === Multiple defaults ===
+def f_multi(a=1, b=2):
+    return a + b
+
+
+assert f_multi() == 3, 'both defaults'
+assert f_multi(10) == 12, 'first provided'
+assert f_multi(10, 20) == 30, 'both provided'
+
+
+# === Mixed required and default ===
+def f_mixed(a, b, c=3, d=4):
+    return a + b + c + d
+
+
+assert f_mixed(1, 2) == 10, 'required only'
+assert f_mixed(1, 2, 30) == 37, 'one default overridden'
+assert f_mixed(1, 2, 30, 40) == 73, 'all provided'
+
+
+# === Default with keyword args ===
+def f_kw(a, b=10):
+    return a + b
+
+
+assert f_kw(1, b=20) == 21, 'keyword override'
+assert f_kw(a=5) == 15, 'keyword required, default used'
+assert f_kw(a=5, b=3) == 8, 'both keywords'
+
+
+# === Default expressions evaluated at definition ===
+# Test that default is evaluated once at definition time
+def value_maker():
+    return 42
+
+
+def f_eval(x=value_maker()):
+    return x
+
+
+# value_maker was called once at function definition time
+assert f_eval() == 42, 'first call uses cached default'
+assert f_eval() == 42, 'second call uses same default'
+
+
+# === Mutable default (Python gotcha - shared across calls) ===
+def f_mutable(lst=[]):
+    lst.append(1)
+    return lst
+
+
+first_result = f_mutable()
+assert first_result == [1], 'first call'
+second_result = f_mutable()
+assert second_result == [1, 1], 'second call appends to same list'
+assert first_result is second_result, 'same list object'
+
+
+# === Multiple functions with separate defaults ===
+def f_sep1(x=[]):
+    x.append('a')
+    return x
+
+
+def f_sep2(x=[]):
+    x.append('b')
+    return x
+
+
+r1 = f_sep1()
+r2 = f_sep2()
+assert r1 == ['a'], 'f_sep1 default'
+assert r2 == ['b'], 'f_sep2 default'
+assert r1 is not r2, 'separate default lists'
+
+
+# === Default referencing earlier param (not supported, different test) ===
+
+
+# === Closure with defaults ===
+def make_adder(n):
+    def add(x, y=n):
+        return x + y
+
+    return add
+
+
+add5 = make_adder(5)
+assert add5(10) == 15, 'closure default from enclosing scope'
+assert add5(10, 3) == 13, 'closure default overridden'
+
+add10 = make_adder(10)
+assert add10(1) == 11, 'different closure, different captured default'
+
+# Verify the two closures have independent defaults
+assert add5(1) == 6, 'add5 still uses 5'
+
+
+# === Keyword-only defaults interleaved ===
+def kwonly_mix(*, head=1, mid, tail=3):
+    return head, mid, tail
+
+
+assert kwonly_mix(mid=2) == (1, 2, 3), 'kw-only defaults applied per parameter'
+assert kwonly_mix(head=5, mid=7) == (5, 7, 3), 'kw-only default overridden independently'

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

@@ -0,0 +1,7 @@
+# Test: same argument passed both positionally and by keyword
+def f(a, b, c):
+    return a + b + c
+
+
+f(1, 2, b=3)
+# Raise=TypeError("f() got multiple values for argument 'b'")

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

@@ -0,0 +1,7 @@
+# Test: first argument passed both positionally and by keyword
+def f(a, b):
+    return a + b
+
+
+f(1, a=2)
+# Raise=TypeError("f() got multiple values for argument 'a'")

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

@@ -0,0 +1,9 @@
+# Test that heap values are properly cleaned up when duplicate kwarg error occurs
+def f(a, b):
+    return a
+
+
+# The list [1, 2, 3] should be cleaned up when the error occurs
+# because 'a' is passed both positionally and by keyword
+f([1, 2, 3], a=[4, 5])
+# Raise=TypeError("f() got multiple values for argument 'a'")

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

@@ -0,0 +1,7 @@
+# Test: keyword-only argument passed positionally
+def f(*, a, b):
+    return a + b
+
+
+f(1, 2)
+# Raise=TypeError('f() takes 0 positional arguments but 2 were given')

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

@@ -0,0 +1,7 @@
+# Test: missing all positional-only arguments
+def f(a, b, /):
+    return a + b
+
+
+f()
+# Raise=TypeError("f() missing 2 required positional arguments: 'a' and 'b'")