superacli 1.1.4 → 1.1.6

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

@@ -0,0 +1,19 @@
+# === tuple.index() ===
+t = (1, 2, 3, 2)
+assert t.index(2) == 1, 'index finds first occurrence'
+assert t.index(3) == 2, 'index finds element'
+assert t.index(2, 2) == 3, 'index with start'
+assert t.index(2, 1, 4) == 1, 'index with start and end'
+
+t = ('a', 'b', 'c')
+assert t.index('b') == 1, 'index string in tuple'
+
+# === tuple.count() ===
+t = (1, 2, 2, 3, 2)
+assert t.count(2) == 3, 'count multiple occurrences'
+assert t.count(1) == 1, 'count single occurrence'
+assert t.count(4) == 0, 'count zero occurrences'
+assert ().count(1) == 0, 'count on empty tuple'
+
+t = ('a', 'b', 'a')
+assert t.count('a') == 2, 'count strings'

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

@@ -0,0 +1,133 @@
+# === Empty tuple identity (singleton optimization) ===
+# In Python, () is () is always True because empty tuples are interned
+assert () is (), 'empty tuple identity'
+assert tuple() is (), 'tuple() is empty tuple'
+assert tuple() is tuple(), 'tuple() identity'
+a = ()
+b = ()
+assert a is b, 'empty tuple vars are same object'
+# Empty tuple from operations
+assert (1,)[1:] is (), 'slice to empty is singleton'
+assert (1, 2) * 0 is (), 'mult by 0 is empty singleton'
+
+# === Tuple length ===
+assert len(()) == 0, 'len empty'
+assert len((1,)) == 1, 'len single'
+assert len((1, 2, 3)) == 3, 'len basic'
+
+# === Tuple indexing ===
+a = (1, 2, 3)
+assert a[1] == 2, 'getitem basic'
+
+a = ('a', 'b', 'c')
+assert a[0 - 2] == 'b', 'getitem negative'
+assert a[-1] == 'c', 'getitem -1'
+
+# === Nested tuples ===
+assert ((1, 2), (3, 4)) == ((1, 2), (3, 4)), 'nested tuple'
+
+# === Tuple repr/str ===
+assert repr((1, 2)) == '(1, 2)', 'tuple repr'
+assert str((1, 2)) == '(1, 2)', 'tuple str'
+
+# === Tuple concatenation (+) ===
+assert (1, 2) + (3, 4) == (1, 2, 3, 4), 'tuple add basic'
+assert () + (1, 2) == (1, 2), 'empty add tuple'
+assert (1, 2) + () == (1, 2), 'tuple add empty'
+assert () + () == (), 'empty add empty'
+assert ('a', 'b') + ('c',) == ('a', 'b', 'c'), 'tuple add strings'
+assert ((1, 2),) + ((3, 4),) == ((1, 2), (3, 4)), 'tuple add nested'
+
+# === Tuple repetition (*) ===
+assert (1, 2) * 3 == (1, 2, 1, 2, 1, 2), 'tuple mult int'
+assert 3 * (1, 2) == (1, 2, 1, 2, 1, 2), 'int mult tuple'
+assert (1,) * 0 == (), 'tuple mult zero'
+assert (1,) * -1 == (), 'tuple mult negative'
+assert () * 5 == (), 'empty tuple mult'
+assert (1, 2) * 1 == (1, 2), 'tuple mult one'
+
+# === Tuple augmented assignment edge cases ===
+t = ([1],)
+try:
+    t[0] += [2]
+    assert False, 'tuple item augmented assignment should fail'
+except TypeError as e:
+    assert e.args == ("'tuple' object does not support item assignment",), 'tuple += error matches CPython'
+    assert t == ([1, 2],), 'inner list mutation happens before tuple store fails'
+
+# === tuple() constructor ===
+assert tuple() == (), 'tuple() empty'
+assert tuple([1, 2, 3]) == (1, 2, 3), 'tuple from list'
+assert tuple((1, 2, 3)) == (1, 2, 3), 'tuple from tuple'
+assert tuple(range(3)) == (0, 1, 2), 'tuple from range'
+assert tuple('abc') == ('a', 'b', 'c'), 'tuple from string'
+assert tuple(b'abc') == (97, 98, 99), 'tuple from bytes'
+assert tuple({'a': 1, 'b': 2}) == ('a', 'b'), 'tuple from dict yields keys'
+
+# non-ASCII strings (multi-byte UTF-8)
+assert tuple('héllo') == ('h', 'é', 'l', 'l', 'o'), 'tuple from string with accented char'
+assert tuple('日本') == ('日', '本'), 'tuple from string with CJK chars'
+assert tuple('a🎉b') == ('a', '🎉', 'b'), 'tuple from string with emoji'
+
+# === Tuple unpacking (PEP 448) ===
+a = (1, 2)
+b = (3, 4)
+assert (*a,) == (1, 2), 'single tuple unpack'
+assert (*a, *b) == (1, 2, 3, 4), 'double tuple unpack'
+assert (0, *a, 5) == (0, 1, 2, 5), 'mixed tuple unpack'
+assert (*(),) == (), 'unpack empty tuple'
+assert (*[1, 2],) == (1, 2), 'unpack list into tuple'
+
+# === Tuple comparison (<, >, <=, >=) ===
+assert (1, 2) < (1, 3), 'lt second element differs'
+assert (1,) < (2,), 'lt single element'
+assert () < (1,), 'lt empty vs non-empty'
+assert (1, 2) < (1, 2, 3), 'lt shorter tuple'
+assert not (1, 2) < (1, 2), 'not lt when equal'
+assert not (1, 3) < (1, 2), 'not lt when greater'
+
+assert (1, 3) > (1, 2), 'gt second element'
+assert (2,) > (1,), 'gt single element'
+assert (1,) > (), 'gt non-empty vs empty'
+assert (1, 2, 3) > (1, 2), 'gt longer tuple'
+assert not (1, 2) > (1, 2), 'not gt when equal'
+
+assert (1, 2) <= (1, 2), 'le when equal'
+assert (1, 2) <= (1, 3), 'le when less'
+assert not (1, 3) <= (1, 2), 'not le when greater'
+
+assert (1, 2) >= (1, 2), 'ge when equal'
+assert (1, 3) >= (1, 2), 'ge when greater'
+assert not (1, 2) >= (1, 3), 'not ge when less'
+
+# === Tuple comparison with sorted() ===
+assert sorted([(2, 'b'), (1, 'a')]) == [(1, 'a'), (2, 'b')], 'sorted tuples'
+assert sorted([(1, 'b'), (1, 'a')]) == [(1, 'a'), (1, 'b')], 'sorted tuples second element'
+assert sorted([(3,), (1,), (2,)]) == [(1,), (2,), (3,)], 'sorted single-element tuples'
+
+# === Nested tuple comparison ===
+assert ((1, 2), 3) < ((1, 3), 2), 'nested tuple comparison'
+assert (1, (2, 3)) < (1, (2, 4)), 'nested tuple inner comparison'
+
+# === Equal-but-unorderable elements (None, lists, dicts) ===
+# CPython checks __eq__ first; equal elements skip ordering comparison
+assert not (1, None) < (1, None), 'equal None elements not lt'
+assert (1, None) <= (1, None), 'equal None elements le'
+assert (1, None) >= (1, None), 'equal None elements ge'
+assert not (1, None) > (1, None), 'equal None elements not gt'
+assert (1, None) < (2, None), 'first element resolves before None'
+assert (1, [1, 2]) <= (1, [1, 2]), 'equal list elements le'
+
+# === Mixed types in tuple comparison ===
+assert (1,) < (2.0,), 'int vs float in tuple'
+assert (1.0,) < (2,), 'float vs int in tuple'
+assert (True,) < (2,), 'bool vs int in tuple'
+assert (False,) < (True,), 'False vs True in tuple'
+assert (1, 'a') < (1, 'b'), 'string comparison in tuple'
+assert ('a', 1) < ('b', 1), 'string first element in tuple'
+
+# === Empty and equal tuples ===
+assert not () < (), 'empty tuples not lt'
+assert () <= (), 'empty tuples le'
+assert () >= (), 'empty tuples ge'
+assert not () > (), 'empty tuples not gt'

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

@@ -0,0 +1,2 @@
+(*42,)
+# Raise=TypeError('Value after * must be an iterable, not int')

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

@@ -0,0 +1,9 @@
+x = len
+x.nonexistent
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "type__builtin_attr_error.py", line 2, in <module>
+    x.nonexistent
+AttributeError: 'builtin_function_or_method' object has no attribute 'nonexistent'
+"""

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

@@ -0,0 +1,2 @@
+bytes(-1)
+# Raise=ValueError('negative count')

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

@@ -0,0 +1,9 @@
+print(cell)
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "type__cell_not_builtin.py", line 1, in <module>
+    print(cell)
+          ~~~~
+NameError: name 'cell' is not defined
+"""

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

@@ -0,0 +1,11 @@
+# Regression test for: "fmt() called on disabled variant" panic
+# Type::Exception must be displayable in error messages.
+e = ValueError('test')
+e.nonexistent
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "type__exception_attr_error.py", line 4, in <module>
+    e.nonexistent
+AttributeError: 'ValueError' object has no attribute 'nonexistent'
+"""

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

@@ -0,0 +1,2 @@
+float([1, 2])
+# Raise=TypeError("float() argument must be a string or a real number, not 'list'")

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

@@ -0,0 +1,9 @@
+float("it's \"nice\"")
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "type__float_repr_both_quotes.py", line 1, in <module>
+    float("it's \"nice\"")
+    ~~~~~~~~~~~~~~~~~~~~~~
+ValueError: could not convert string to float: 'it\'s "nice"'
+"""

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

@@ -0,0 +1,9 @@
+float("a\nb")
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "type__float_repr_newline.py", line 1, in <module>
+    float("a\nb")
+    ~~~~~~~~~~~~~
+ValueError: could not convert string to float: 'a\nb'
+"""

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

@@ -0,0 +1,9 @@
+float("it's")
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "type__float_repr_single_quote.py", line 1, in <module>
+    float("it's")
+    ~~~~~~~~~~~~~
+ValueError: could not convert string to float: "it's"
+"""

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

@@ -0,0 +1,2 @@
+int([1, 2])
+# Raise=TypeError("int() argument must be a string, a bytes-like object or a real number, not 'list'")

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

@@ -0,0 +1,2 @@
+list(123)
+# Raise=TypeError("'int' object is not iterable")

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

@@ -0,0 +1,9 @@
+print(TextIOWrapper)
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "type__non_builtin_name_error.py", line 1, in <module>
+    print(TextIOWrapper)
+          ~~~~~~~~~~~~~
+NameError: name 'TextIOWrapper' is not defined
+"""

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

@@ -0,0 +1,200 @@
+# === type() function ===
+assert type(1) == int, 'type(int) returns int'
+assert type(1.5) == float, 'type(float) returns float'
+assert type(True) == bool, 'type(bool) returns bool'
+assert type('hello') == str, 'type(str) returns str'
+assert type([1, 2]) == list, 'type(list) returns list'
+assert type((1, 2)) == tuple, 'type(tuple) returns tuple'
+assert type({1: 2}) == dict, 'type(dict) returns dict'
+assert type(b'hi') == bytes, 'type(bytes) returns bytes'
+assert type(None) == type(None), 'type(None) is consistent'
+
+# === type() inequality ===
+assert type(1) != str, 'int type != str'
+assert type([]) != tuple, 'list type != tuple'
+assert type({}) != list, 'dict type != list'
+assert type(1) != float, 'int type != float'
+
+# === type repr ===
+assert repr(int) == "<class 'int'>", 'int type repr'
+assert repr(float) == "<class 'float'>", 'float type repr'
+assert repr(bool) == "<class 'bool'>", 'bool type repr'
+assert repr(str) == "<class 'str'>", 'str type repr'
+assert repr(list) == "<class 'list'>", 'list type repr'
+assert repr(tuple) == "<class 'tuple'>", 'tuple type repr'
+assert repr(dict) == "<class 'dict'>", 'dict type repr'
+assert repr(bytes) == "<class 'bytes'>", 'bytes type repr'
+
+# === type identity ===
+assert int is int, 'int is int'
+assert str is str, 'str is str'
+assert list is list, 'list is list'
+assert type(1) is int, 'type(1) is int'
+assert type('') is str, 'type str is str'
+assert type([]) is list, 'type([]) is list'
+
+# === list() constructor ===
+assert list() == [], 'list() empty'
+assert list([1, 2, 3]) == [1, 2, 3], 'list(list) copy'
+assert list((1, 2, 3)) == [1, 2, 3], 'list(tuple) convert'
+assert list(range(3)) == [0, 1, 2], 'list(range) convert'
+assert list('abc') == ['a', 'b', 'c'], 'list(str) split chars'
+assert list('') == [], 'list empty str'
+
+# list copy is independent
+orig = [1, 2, 3]
+copy = list(orig)
+copy.append(4)
+assert orig == [1, 2, 3], 'list copy is independent'
+assert copy == [1, 2, 3, 4], 'list copy modified'
+
+# === tuple() constructor ===
+assert tuple() == (), 'tuple() empty'
+assert tuple([1, 2, 3]) == (1, 2, 3), 'tuple(list) convert'
+assert tuple((1, 2)) == (1, 2), 'tuple(tuple) copy'
+assert tuple(range(3)) == (0, 1, 2), 'tuple(range) convert'
+assert tuple('ab') == ('a', 'b'), 'tuple(str) split chars'
+assert tuple('') == (), 'tuple empty str'
+
+# === dict() constructor ===
+assert dict() == {}, 'dict() empty'
+assert dict({1: 2}) == {1: 2}, 'dict(dict) copy'
+assert dict({'a': 1, 'b': 2}) == {'a': 1, 'b': 2}, 'dict(dict) multiple keys'
+
+# dict copy is independent
+orig_dict = {1: 2}
+copy_dict = dict(orig_dict)
+copy_dict[3] = 4
+assert orig_dict == {1: 2}, 'dict copy is independent'
+assert copy_dict == {1: 2, 3: 4}, 'dict copy modified'
+assert dict([('a', 1), ('b', 2)]) == {'a': 1, 'b': 2}, 'dict(list of tuples)'
+assert dict((('a', 1), ('b', 2))) == {'a': 1, 'b': 2}, 'dict(tuple of tuples)'
+
+headers = ['a', 'b']
+row_data = [1, 2]
+assert dict(zip(headers, row_data)) == {'a': 1, 'b': 2}, 'dict(zip(list, list))'
+assert dict(zip(['a', 'b'], [1])) == {'a': 1}, 'dict(zip()) truncates to shortest iterable'
+
+assert dict(a=1, b=2) == {'a': 1, 'b': 2}, 'dict keyword arguments'
+assert dict([('a', 1)], b=2) == {'a': 1, 'b': 2}, 'dict positional iterable plus kwargs'
+assert dict([('a', 1)], a=2) == {'a': 2}, 'dict kwargs overwrite positional iterable values'
+
+# === str() constructor ===
+assert str() == '', 'str() empty'
+assert str(123) == '123', 'str(int)'
+assert str(-42) == '-42', 'str(negative int)'
+assert str(0) == '0', 'str(zero)'
+assert str(1.5) == '1.5', 'str(float)'
+assert str(True) == 'True', 'str(bool True)'
+assert str(False) == 'False', 'str(bool False)'
+assert str(None) == 'None', 'str(None)'
+assert str([1, 2]) == '[1, 2]', 'str(list)'
+assert str((1, 2)) == '(1, 2)', 'str(tuple)'
+assert str({1: 2}) == '{1: 2}', 'str(dict)'
+assert str('hello') == 'hello', 'str(str)'
+assert str(b'hi') == "b'hi'", 'str(bytes)'
+
+# === bytes() constructor ===
+assert bytes() == b'', 'bytes() empty'
+assert bytes(3) == b'\x00\x00\x00', 'bytes(int) zero-filled'
+assert bytes(0) == b'', 'bytes(0) empty'
+assert bytes(b'hi') == b'hi', 'bytes(bytes) copy'
+
+# === int() constructor ===
+assert int() == 0, 'int() default'
+assert int(42) == 42, 'int(int)'
+assert int(-5) == -5, 'int(negative int)'
+assert int(3.7) == 3, 'int(float) truncates down'
+assert int(-3.7) == -3, 'int(negative float) truncates toward zero'
+assert int(3.0) == 3, 'int(whole float)'
+assert int(True) == 1, 'int(True)'
+assert int(False) == 0, 'int(False)'
+
+# int() with extreme float values (should clamp to i64 range in Monty)
+# Note: Python uses arbitrary precision; Monty clamps to i64
+assert isinstance(int(1e18), int), 'int(large float) returns int'
+assert isinstance(int(-1e18), int), 'int(large negative float) returns int'
+assert int(0.0) == 0, 'int(0.0) is zero'
+assert int(-0.0) == 0, 'int(-0.0) is zero'
+assert int(0.9) == 0, 'int(0.9) truncates to 0'
+assert int(-0.9) == 0, 'int(-0.9) truncates to 0'
+
+# === float() constructor ===
+assert float() == 0.0, 'float() default'
+assert float(42) == 42.0, 'float(int)'
+assert float(-5) == -5.0, 'float(negative int)'
+assert float(3.14) == 3.14, 'float(float)'
+assert float(True) == 1.0, 'float(True)'
+assert float(False) == 0.0, 'float(False)'
+
+# === bool() constructor ===
+assert bool() == False, 'bool() default'
+assert bool(0) == False, 'bool(0)'
+assert bool(1) == True, 'bool(1)'
+assert bool(-1) == True, 'bool(-1)'
+assert bool(0.0) == False, 'bool(0.0)'
+assert bool(1.5) == True, 'bool(1.5)'
+assert bool('') == False, 'bool empty str'
+assert bool('x') == True, 'bool non-empty str'
+assert bool([]) == False, 'bool empty list'
+assert bool([1]) == True, 'bool non-empty list'
+assert bool(()) == False, 'bool empty tuple'
+assert bool((1,)) == True, 'bool non-empty tuple'
+assert bool({}) == False, 'bool empty dict'
+assert bool({1: 2}) == True, 'bool non-empty dict'
+assert bool(None) == False, 'bool(None)'
+
+# === isinstance() ===
+assert isinstance(1, int), 'isinstance int'
+assert isinstance(1.5, float), 'isinstance float'
+assert isinstance(True, bool), 'isinstance bool'
+assert isinstance('hello', str), 'isinstance str'
+assert isinstance([1, 2], list), 'isinstance list'
+assert isinstance((1, 2), tuple), 'isinstance tuple'
+assert isinstance({1: 2}, dict), 'isinstance dict'
+assert isinstance(b'hi', bytes), 'isinstance bytes'
+
+# isinstance negative cases
+assert not isinstance(1, str), 'isinstance int not str'
+assert not isinstance('x', int), 'isinstance str not int'
+assert not isinstance([], dict), 'isinstance list not dict'
+
+# isinstance with tuple of types
+assert isinstance(1, (int, str)), 'isinstance tuple match first'
+assert isinstance('x', (int, str)), 'isinstance tuple match second'
+assert not isinstance([], (int, str)), 'isinstance tuple no match'
+assert isinstance(1, (str, float, int)), 'isinstance tuple match third'
+
+# bool is subtype of int
+assert isinstance(True, int), 'bool is instance of int'
+assert isinstance(False, int), 'False is instance of int'
+assert isinstance(True, (int, str)), 'bool matches int in tuple'
+
+# isinstance with exception types
+err = ValueError('test')
+assert isinstance(err, ValueError), 'isinstance exception'
+assert isinstance(err, Exception), 'isinstance exception base type'
+assert not isinstance(err, TypeError), 'isinstance exception wrong type'
+assert isinstance(err, (ValueError, TypeError)), 'isinstance exception tuple'
+
+# isinstance with nested tuples
+assert isinstance('a', (int, (str, bytes))), 'isinstance nested tuple match'
+assert isinstance(1, ((str, float), int)), 'isinstance deeply nested'
+assert not isinstance([], (int, (str, bytes))), 'isinstance nested tuple no match'
+
+# NoneType capitalization
+assert repr(type(None)) == "<class 'NoneType'>", 'NoneType capitalized'
+
+# === type().__name__ ===
+assert type(42).__name__ == 'int', 'int type name'
+assert type('hello').__name__ == 'str', 'str type name'
+assert type(True).__name__ == 'bool', 'bool type name'
+assert type(None).__name__ == 'NoneType', 'NoneType name'
+assert type([1, 2]).__name__ == 'list', 'list type name'
+assert type({'a': 1}).__name__ == 'dict', 'dict type name'
+
+# type().__name__ for exceptions
+try:
+    raise ValueError('test')
+except ValueError as e:
+    assert type(e).__name__ == 'ValueError', 'exception type name'

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

@@ -0,0 +1,3 @@
+# Builtin exception type 'ValueError' can be shadowed by assignment
+ValueError = 'not an exception'
+assert ValueError == 'not an exception', 'ValueError shadowed'

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

@@ -0,0 +1,9 @@
+# Builtin type name 'int' can be shadowed by assignment
+int = 42
+assert int == 42, 'int shadowed by assignment'
+
+# for loop variable shadows builtin
+result = []
+for int in range(3):
+    result.append(int)
+assert result == [0, 1, 2], 'int works as for loop variable'

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

@@ -0,0 +1,3 @@
+# Builtin function 'len' can be shadowed by assignment
+len = 'shadowed'
+assert len == 'shadowed', 'len shadowed by assignment'

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

@@ -0,0 +1,2 @@
+tuple(123)
+# Raise=TypeError("'int' object is not iterable")

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

@@ -0,0 +1,2 @@
+2 + [1]
+# Raise=TypeError("unsupported operand type(s) for +: 'int' and 'list'")

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

@@ -0,0 +1,2 @@
+5 / 'x'
+# Raise=TypeError("unsupported operand type(s) for /: 'int' and 'str'")

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

@@ -0,0 +1,2 @@
+5 // 'x'
+# Raise=TypeError("unsupported operand type(s) for //: 'int' and 'str'")

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

@@ -0,0 +1,3 @@
+x = 5
+x += 'a'
+# Raise=TypeError("unsupported operand type(s) for +=: 'int' and 'str'")

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

@@ -0,0 +1,2 @@
+5 % 'x'
+# Raise=TypeError("unsupported operand type(s) for %: 'int' and 'str'")

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

@@ -0,0 +1,2 @@
+5 ** 'x'
+# Raise=TypeError("unsupported operand type(s) for ** or pow(): 'int' and 'str'")

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

@@ -0,0 +1,2 @@
+5 - 'x'
+# Raise=TypeError("unsupported operand type(s) for -: 'int' and 'str'")

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

@@ -0,0 +1,2 @@
+[1, 2] + 3
+# Raise=TypeError('can only concatenate list (not "int") to list')

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

@@ -0,0 +1,2 @@
+[1] + 'x'
+# Raise=TypeError('can only concatenate list (not "str") to list')

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

@@ -0,0 +1,6 @@
+# xfail=monty
+# Monty's list += only supports other lists, not arbitrary iterables.
+# CPython's list += calls extend() which requires an iterable.
+x = [1]
+x += 2
+# Raise=TypeError("'int' object is not iterable")

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

@@ -0,0 +1,2 @@
+'hello' + 1
+# Raise=TypeError('can only concatenate str (not "int") to str')

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

@@ -0,0 +1,3 @@
+x = 'hello'
+x += 1
+# Raise=TypeError('can only concatenate str (not "int") to str')

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

@@ -0,0 +1,3 @@
+# bitwise NOT on string should raise TypeError
+~'hello'
+# Raise=TypeError("bad operand type for unary ~: 'str'")

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

@@ -0,0 +1,4 @@
+# unary minus on heap-allocated string should raise TypeError
+# str() creates a heap-allocated string, triggering ref count check
+-str(42)
+# Raise=TypeError("bad operand type for unary -: 'str'")

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

@@ -0,0 +1,3 @@
+# unary minus on string should raise TypeError
+-'hello'
+# Raise=TypeError("bad operand type for unary -: 'str'")

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

@@ -0,0 +1,4 @@
+# unary plus on heap-allocated string should raise TypeError
+# str() creates a heap-allocated string, triggering ref count check
++str(42)
+# Raise=TypeError("bad operand type for unary +: 'str'")

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

@@ -0,0 +1,24 @@
+# Tests for typing module type() behavior
+#
+# CPython's typing module uses various internal types for different constructs.
+# Monty simplifies this by using typing._SpecialForm for all typing markers.
+# Where CPython also uses _SpecialForm, we use == for exact match.
+# Where CPython uses different internal types, we accept both representations.
+
+import typing
+
+# === Types that match between CPython and Monty ===
+assert repr(type(typing.Optional)) == "<class 'typing._SpecialForm'>", 'type(Optional)'
+assert repr(type(typing.ClassVar)) == "<class 'typing._SpecialForm'>", 'type(ClassVar)'
+assert repr(type(typing.Final)) == "<class 'typing._SpecialForm'>", 'type(Final)'
+assert repr(type(typing.Union)) == "<class 'type'>", 'type(Union)'
+
+# === Types that differ between CPython and Monty ===
+# CPython uses specialized internal types; Monty uses _SpecialForm for all
+assert repr(type(typing.Any)) in ("<class 'typing._SpecialForm'>", "<class 'typing._AnyMeta'>"), 'type(Any)'
+assert repr(type(typing.Callable)) in ("<class 'typing._SpecialForm'>", "<class 'typing._CallableType'>"), (
+    'type(Callable)'
+)
+
+# === Verify TYPE_CHECKING is False ===
+assert typing.TYPE_CHECKING is False, 'TYPE_CHECKING should be False at runtime'

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

@@ -0,0 +1,48 @@
+# Test nested tuple unpacking
+
+# === Basic nested unpacking ===
+data = ((1, 2), 'x')
+(a, b), c = data
+assert a == 1, 'nested unpack first inner'
+assert b == 2, 'nested unpack second inner'
+assert c == 'x', 'nested unpack outer'
+
+# === Deeply nested ===
+((a, b), (c, d)) = ((1, 2), (3, 4))
+assert a == 1, 'deep nested first'
+assert b == 2, 'deep nested second'
+assert c == 3, 'deep nested third'
+assert d == 4, 'deep nested fourth'
+
+# === Mixed depths ===
+(a, (b, c)) = (1, (2, 3))
+assert a == 1, 'mixed depth outer'
+assert b == 2, 'mixed depth inner first'
+assert c == 3, 'mixed depth inner second'
+
+# === Three levels deep ===
+(a, (b, (c, d))) = (1, (2, (3, 4)))
+assert a == 1, 'three level outer'
+assert b == 2, 'three level mid'
+assert c == 3, 'three level inner first'
+assert d == 4, 'three level inner second'
+
+# === In for loops ===
+items = [((1, 2), 'a'), ((3, 4), 'b')]
+sums = []
+letters = []
+for (a, b), c in items:
+    sums.append(a + b)
+    letters.append(c)
+assert sums == [3, 7], 'for loop nested unpack sums'
+assert letters == ['a', 'b'], 'for loop nested unpack letters'
+
+# === In comprehensions ===
+items = [((1, 2), 'a'), ((3, 4), 'b')]
+result = [a + b for (a, b), c in items]
+assert result == [3, 7], 'comprehension nested unpack'
+
+# === Deep nested in comprehension ===
+items = [((1, 2), (3, 4)), ((5, 6), (7, 8))]
+result = [a + b + c + d for (a, b), (c, d) in items]
+assert result == [10, 26], 'comprehension deep nested unpack'

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

@@ -0,0 +1,9 @@
+a, b = 42
+"""
+TRACEBACK:
+Traceback (most recent call last):
+  File "unpack__non_sequence.py", line 1, in <module>
+    a, b = 42
+    ~~~~
+TypeError: cannot unpack non-iterable int object
+"""