superacli 1.1.4 → 1.1.6

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

@@ -0,0 +1,241 @@
+# Tests for the re (regular expression) module - capture groups and grouping
+
+import re
+
+# === Capture groups ===
+m = re.search(r'(\w+)@(\w+)', 'user@host')
+assert m is not None, 're.search with groups finds a match'
+assert m.group(0) == 'user@host', 'group(0) is the full match'
+assert m.group(1) == 'user', 'group(1) is first capture'
+assert m.group(2) == 'host', 'group(2) is second capture'
+assert m.groups() == ('user', 'host'), 'groups() returns tuple of captures'
+
+# === group start/end/span with capture groups ===
+m = re.search(r'(\w+)@(\w+)', 'email: user@host here')
+assert m is not None, 'search with groups finds match'
+assert m.start(0) == 7, 'start(0) is full match start'
+assert m.end(0) == 16, 'end(0) is full match end'
+assert m.start(1) == 7, 'start(1) is group 1 start'
+assert m.end(1) == 11, 'end(1) is group 1 end'
+assert m.span(1) == (7, 11), 'span(1) is group 1 span'
+assert m.start(2) == 12, 'start(2) is group 2 start'
+assert m.end(2) == 16, 'end(2) is group 2 end'
+assert m.span(2) == (12, 16), 'span(2) is group 2 span'
+
+# === re.findall() with one group ===
+result = re.findall(r'(\d+)', 'a1 b22 c333')
+assert result == ['1', '22', '333'], 'findall with one group returns list of group strings'
+
+# === re.findall() with multiple groups ===
+result = re.findall(r'(\w+)=(\w+)', 'a=1 b=2')
+assert result == [('a', '1'), ('b', '2')], 'findall with multiple groups returns list of tuples'
+
+# === No groups: groups() returns empty tuple ===
+m = re.search(r'\d+', '42')
+assert m is not None, 'search with no groups finds match'
+assert m.groups() == (), 'groups() with no capture groups returns empty tuple'
+
+# === Backreferences ===
+m = re.search(r'(\w+)\s+\1', 'hello hello')
+assert m is not None, 'backreference finds repeated word'
+assert m.group(0) == 'hello hello', 'backreference full match'
+assert m.group(1) == 'hello', 'backreference group'
+
+# === Invalid group index ===
+m = re.search(r'(\w+)', 'hello')
+assert m is not None, 'search with group finds match'
+try:
+    m.group(2)
+    assert False, 'Accessing invalid group index should raise IndexError'
+except IndexError as e:
+    assert str(e) == 'no such group'
+try:
+    m.group('foo')
+    assert False, 'Accessing group with non-integer index should raise IndexError'
+except IndexError as e:
+    assert str(e) == 'no such group'
+
+# === re.sub() replacement with backreferences ===
+result = re.sub(r'(\w+)=(\w+)', r'\2=\1', 'a=1 b=2')
+assert result == '1=a 2=b', 're.sub with backreferences swaps groups'
+
+# === Negative group index ===
+m = re.search(r'(\w+)', 'hello')
+assert m is not None, 'search with group finds match'
+try:
+    m.group(-1)
+    assert False, 'Negative group index should raise IndexError'
+except IndexError as e:
+    assert str(e) == 'no such group', 'negative group raises IndexError with "no such group" message'
+
+# === Out-of-range group index ===
+m = re.search(r'(\w+)', 'hello')
+assert m is not None, 'search with group finds match'
+try:
+    m.group(999)
+    assert False, 'Out-of-range group index should raise IndexError'
+except IndexError as e:
+    assert str(e) == 'no such group', 'out-of-range group raises IndexError with "no such group" message'
+
+# === Non-integer group argument: float ===
+m = re.search(r'(\w+)', 'hello')
+assert m is not None, 'search with group finds match'
+try:
+    m.group(1.5)
+    assert False, 'Float group argument should raise IndexError'
+except IndexError as e:
+    assert str(e) == 'no such group', 'float group arg raises IndexError'
+
+# === Non-integer group argument: string ===
+m = re.search(r'(\w+)', 'hello')
+assert m is not None, 'search with group finds match'
+try:
+    m.group('1')
+    assert False, 'String group argument should raise IndexError'
+except IndexError as e:
+    assert str(e) == 'no such group', 'string group arg raises IndexError'
+
+# === Non-integer group argument: None ===
+m = re.search(r'(\w+)', 'hello')
+assert m is not None, 'search with group finds match'
+try:
+    m.group(None)
+    assert False, 'None group argument should raise IndexError'
+except IndexError as e:
+    assert str(e) == 'no such group', 'None group arg raises IndexError'
+
+# === Negative group index for start() ===
+m = re.search(r'(\w+)@(\w+)', 'user@host')
+assert m is not None, 'search with groups finds match'
+try:
+    m.start(-1)
+    assert False, 'Negative start index should raise IndexError'
+except IndexError as e:
+    assert str(e) == 'no such group', 'negative start raises IndexError with "no such group" message'
+
+# === Out-of-range group index for start() ===
+m = re.search(r'(\w+)@(\w+)', 'user@host')
+assert m is not None, 'search with groups finds match'
+try:
+    m.start(999)
+    assert False, 'Out-of-range start index should raise IndexError'
+except IndexError as e:
+    assert str(e) == 'no such group', 'out-of-range start raises IndexError'
+
+# === Non-integer argument for start() ===
+m = re.search(r'(\w+)', 'hello')
+assert m is not None, 'search with group finds match'
+try:
+    m.start(1.5)
+    assert False, 'Float start argument should raise IndexError'
+except IndexError as e:
+    assert str(e) == 'no such group', 'float start arg raises IndexError'
+
+# === Negative group index for end() ===
+m = re.search(r'(\w+)', 'hello')
+assert m is not None, 'search with group finds match'
+try:
+    m.end(-2)
+    assert False, 'Negative end index should raise IndexError'
+except IndexError as e:
+    assert str(e) == 'no such group', 'negative end raises IndexError with "no such group" message'
+
+# === Out-of-range group index for end() ===
+m = re.search(r'(\w+)', 'hello')
+assert m is not None, 'search with group finds match'
+try:
+    m.end(100)
+    assert False, 'Out-of-range end index should raise IndexError'
+except IndexError as e:
+    assert str(e) == 'no such group', 'out-of-range end raises IndexError'
+
+# === Non-integer argument for end() ===
+m = re.search(r'(\w+)', 'hello')
+assert m is not None, 'search with group finds match'
+try:
+    m.end('0')
+    assert False, 'String end argument should raise IndexError'
+except IndexError as e:
+    assert str(e) == 'no such group', 'string end arg raises IndexError'
+
+# === Negative group index for span() ===
+m = re.search(r'(\w+)', 'hello')
+assert m is not None, 'search with group finds match'
+try:
+    m.span(-1)
+    assert False, 'Negative span index should raise IndexError'
+except IndexError as e:
+    assert str(e) == 'no such group', 'negative span raises IndexError with "no such group" message'
+
+# === Out-of-range group index for span() ===
+m = re.search(r'(\w+)@(\w+)', 'user@host')
+assert m is not None, 'search with groups finds match'
+try:
+    m.span(5)
+    assert False, 'Out-of-range span index should raise IndexError'
+except IndexError as e:
+    assert str(e) == 'no such group', 'out-of-range span raises IndexError'
+
+# === Non-integer argument for span() ===
+m = re.search(r'(\w+)', 'hello')
+assert m is not None, 'search with group finds match'
+try:
+    m.span(None)
+    assert False, 'None span argument should raise IndexError'
+except IndexError as e:
+    assert str(e) == 'no such group', 'None span arg raises IndexError'
+
+# === Accessing unmatched optional group returns None ===
+# Optional groups that don't match return None instead of raising an error
+m = re.search(r'(\w+)?@(\w+)', '@host')
+assert m is not None, 'search with optional group finds match'
+assert m.group(1) is None, 'unmatched optional group returns None'
+assert m.start(1) == -1, 'start of unmatched optional group returns -1'
+assert m.end(1) == -1, 'end of unmatched optional group returns -1'
+assert m.span(1) == (-1, -1), 'span of unmatched optional group returns (-1, -1)'
+
+# === Named group access with m.group('name') ===
+m = re.search(r'(?P<first>\w+)\s+(?P<second>\w+)', 'hello world')
+assert m is not None, 'named group search finds match'
+assert m.group('first') == 'hello', "group('first') returns first named group"
+assert m.group('second') == 'world', "group('second') returns second named group"
+assert m.group(1) == 'hello', 'named group is also accessible by index'
+assert m.group(2) == 'world', 'named group is also accessible by index'
+assert m.group(0) == 'hello world', 'group(0) still returns full match'
+
+# Named group with invalid name
+try:
+    m.group('nonexistent')
+    assert False, 'non-existent named group should raise IndexError'
+except IndexError as e:
+    assert str(e) == 'no such group', 'non-existent named group error message'
+
+# === m.group() with multiple arguments ===
+m = re.search(r'(\w+)\s+(\w+)\s+(\w+)', 'a b c')
+assert m is not None, 'multi-group search finds match'
+result = m.group(1, 2)
+assert result == ('a', 'b'), 'group(1, 2) returns tuple of two groups'
+
+result = m.group(1, 2, 3)
+assert result == ('a', 'b', 'c'), 'group(1, 2, 3) returns tuple of three groups'
+
+result = m.group(0, 1)
+assert result == ('a b c', 'a'), 'group(0, 1) includes full match'
+
+# === m.groupdict() ===
+m = re.search(r'(?P<first>\w+)\s+(?P<second>\w+)', 'hello world')
+assert m is not None, 'named group search for groupdict'
+d = m.groupdict()
+assert d == {'first': 'hello', 'second': 'world'}, 'groupdict returns correct dict'
+
+# groupdict with no named groups
+m = re.search(r'(\w+)\s+(\w+)', 'hello world')
+assert m is not None, 'unnamed group search for groupdict'
+d = m.groupdict()
+assert d == {}, 'groupdict with no named groups returns empty dict'
+
+# groupdict with unmatched optional named group
+m = re.search(r'(?P<first>\w+)?@(?P<second>\w+)', '@host')
+assert m is not None, 'optional named group search for groupdict'
+d = m.groupdict()
+assert d == {'first': None, 'second': 'host'}, 'groupdict includes unmatched named groups as None'

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

@@ -0,0 +1,148 @@
+# Tests for the re (regular expression) module - Match object
+
+import re
+
+# === Match .string attribute ===
+m = re.search('hello', 'say hello')
+assert m is not None, 'search finds match for .string test'
+assert m.string == 'say hello', '.string returns the input string'
+
+# === Match truthiness ===
+m = re.search(r'\d+', '123')
+assert m, 'Match objects are truthy'
+
+# === Match repr ===
+m = re.search(r'\d+', 'abc 42 def')
+assert repr(m) == "<re.Match object; span=(4, 6), match='42'>", 'Match repr'
+
+# === Object basic ===
+assert bool(re.search(r'\w+', 'hello'))
+assert isinstance(re.search(r'\w+', 'hello'), re.Match), 're.search returns re.Match instance'
+assert str(type(re.search(r'\w+', 'hello'))) == "<class 're.Match'>", 'type of search match is re.Match'
+
+# === Match equality - Match objects are not comparable ===
+m1 = re.search(r'\w+', 'hello')
+m2 = re.search(r'\w+', 'hello')
+assert (m1 == m2) == False, 'different Match objects are not equal'
+assert m1 != m2, 'Match objects with same content are not equal'
+
+# === Match methods are reusable on same object ===
+m = re.search(r'(\w+)@(\w+)', 'user@host')
+assert m is not None, 'search finds match'
+assert m.group(0) == 'user@host', 'first call to group(0) works'
+assert m.group(0) == 'user@host', 'second call to group(0) works'
+assert m.group(1) == 'user', 'call to group(1) works'
+assert m.start(1) == 0, 'start(1) works'
+assert m.end(1) == 4, 'end(1) works'
+assert m.span(0) == (0, 9), 'span(0) works'
+
+# === .string attribute is accessible multiple times ===
+m = re.search(r'hello', 'say hello world')
+assert m is not None, 'search finds match'
+assert m.string == 'say hello world', 'first access to .string works'
+assert m.string == 'say hello world', 'second access to .string works'
+
+# === Match object with empty string ===
+m = re.search(r'', 'hello')
+assert m is not None, 'empty pattern matches'
+assert m.string == 'hello', '.string returns input for empty match'
+assert m.group(0) == '', 'empty match group(0) is empty string'
+
+# === Match object from match() function ===
+m = re.match(r'(\w+)', 'hello world')
+assert m is not None, 're.match finds match'
+assert m.group(0) == 'hello', 'match() returns correct match'
+assert m.start(0) == 0, 'match starts at position 0'
+assert m.string == 'hello world', '.string returns full input'
+
+# === Match object from fullmatch() function ===
+m = re.fullmatch(r'\w+', 'hello')
+assert m is not None, 're.fullmatch finds exact match'
+assert m.group(0) == 'hello', 'fullmatch returns correct match'
+assert m.start(0) == 0, 'fullmatch starts at position 0'
+assert m.end(0) == 5, 'fullmatch ends at correct position'
+
+# === Match repr basic format ===
+m = re.search(r'\d+', 'abc 42 def')
+assert repr(m) == "<re.Match object; span=(4, 6), match='42'>", 'Match repr basic format'
+
+m = re.search(r'\w+', 'hello')
+assert repr(m) == "<re.Match object; span=(0, 5), match='hello'>", 'Match repr at start'
+
+m = re.search(r'', 'hello')
+assert repr(m) == "<re.Match object; span=(0, 0), match=''>", 'Match repr empty match'
+
+# === Match repr with special characters ===
+p = re.compile(r'a.b', re.DOTALL)
+m = p.search('a\nb')
+assert m is not None, 'DOTALL match for repr test'
+r = repr(m)
+assert r == "<re.Match object; span=(0, 3), match='a\\nb'>", 'Match repr escapes newline'
+
+m = re.search(r'a.b', 'a\tb')
+assert m is not None, 'tab match for repr test'
+r = repr(m)
+assert r == "<re.Match object; span=(0, 3), match='a\\tb'>", 'Match repr escapes tab'
+
+# backslash in matched text
+m = re.search(r'a.b', 'a\\b')
+assert m is not None, 'backslash match for repr test'
+r = repr(m)
+assert r == "<re.Match object; span=(0, 3), match='a\\\\b'>", 'Match repr escapes backslash'
+
+# carriage return in matched text
+p = re.compile(r'a.b', re.DOTALL)
+m = p.search('a\rb')
+assert m is not None, 'carriage return match for repr test'
+r = repr(m)
+assert r == "<re.Match object; span=(0, 3), match='a\\rb'>", 'Match repr escapes carriage return'
+
+# single quote in matched text — repr switches to double quotes
+m = re.search(r'a.b', "a'b")
+assert m is not None, 'single quote match for repr test'
+r = repr(m)
+assert r == '<re.Match object; span=(0, 3), match="a\'b">', 'Match repr handles single quote'
+
+# double quote in matched text — repr uses single quotes
+m = re.search(r'a.b', 'a"b')
+assert m is not None, 'double quote match for repr test'
+r = repr(m)
+assert r == "<re.Match object; span=(0, 3), match='a\"b'>", 'Match repr handles double quote'
+
+# === Pattern repr ===
+p = re.compile('hello')
+assert repr(p) == "re.compile('hello')", 'Pattern repr simple string'
+
+p = re.compile(r'\n\t')
+assert repr(p) == "re.compile('\\\\n\\\\t')", 'Pattern repr with escape sequences in pattern'
+
+# === Bool as group index ===
+m = re.search(r'(\w+)\s+(\w+)', 'hello world')
+assert m is not None, 'search for bool group test'
+assert m.group(True) == 'hello', 'group(True) is group(1)'
+assert m.group(False) == 'hello world', 'group(False) is group(0)'
+assert m.start(True) == 0, 'start(True) is start(1)'
+assert m.end(True) == 5, 'end(True) is end(1)'
+assert m.span(True) == (0, 5), 'span(True) is span(1)'
+assert m.span(False) == (0, 11), 'span(False) is span(0)'
+
+# === m[N] subscript access ===
+m = re.search(r'(\w+)\s+(\w+)', 'hello world')
+assert m is not None, 'search for subscript test'
+assert m[0] == 'hello world', 'm[0] is full match'
+assert m[1] == 'hello', 'm[1] is first group'
+assert m[2] == 'world', 'm[2] is second group'
+
+# subscript with named groups
+m = re.search(r'(?P<first>\w+)\s+(?P<second>\w+)', 'hello world')
+assert m is not None, 'search for named subscript test'
+assert m['first'] == 'hello', "m['first'] accesses named group"
+assert m['second'] == 'world', "m['second'] accesses named group"
+assert m[1] == 'hello', 'm[1] also works with named groups'
+
+# subscript with invalid index
+try:
+    m[99]
+    assert False, 'out-of-range subscript should raise IndexError'
+except IndexError as e:
+    assert str(e) == 'no such group', 'subscript IndexError message'

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

@@ -0,0 +1,26 @@
+# Test that dropping deeply nested containers doesn't crash (stack overflow).
+# Heap::dec_ref recurses in Rust when freeing child references, so deeply
+# nested containers can overflow the Rust call stack during cleanup.
+# CPython handles this fine (its dealloc uses an iterative trashcan mechanism).
+# Once fixed (iterative dec_ref), this should work without crashing.
+
+# === Deep list drop ===
+x = [1]
+for _ in range(10000):
+    x = [x]
+x = None  # triggers recursive dec_ref chain
+assert True, 'survived deep list drop'
+
+# === Deep tuple drop ===
+y = (1,)
+for _ in range(10000):
+    y = (y,)
+y = None  # triggers recursive dec_ref chain
+assert True, 'survived deep tuple drop'
+
+# === Deep dict drop ===
+z = {'a': 1}
+for _ in range(10000):
+    z = {'a': z}
+z = None  # triggers recursive dec_ref chain
+assert True, 'survived deep dict drop'

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

@@ -0,0 +1,23 @@
+# Test that deeply nested lists don't crash during equality comparison
+# Monty raises RecursionError at depth limit, CPython handles in C code
+a = []
+b = []
+for _ in range(30):  # Use lower depth that works within unified recursion limit
+    a = [a]
+    b = [b]
+
+# Should not crash
+result = a == b
+assert isinstance(result, bool), 'comparison should return a bool'
+assert result == True, 'structurally equal nested lists should be equal'
+
+# Test non-equal nested lists
+c = []
+for _ in range(30):
+    c = [c]
+c = [1]  # Make the innermost different
+for _ in range(29):
+    c = [c]
+
+result2 = a == c
+assert result2 == False, 'structurally different nested lists should not be equal'

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

@@ -0,0 +1,46 @@
+# Test that hashing deeply nested containers raises RecursionError instead
+# of crashing with a Rust stack overflow.
+
+# === Deep tuple hash ===
+x = (1,)
+for _ in range(10000):
+    x = (x,)
+
+try:
+    h = hash(x)
+    assert isinstance(h, int), 'hash should return an int'
+except RecursionError:
+    pass  # acceptable if depth guard triggers
+
+# === Deep frozenset hash ===
+y = frozenset({1})
+for _ in range(10000):
+    y = frozenset({y})
+
+try:
+    h = hash(y)
+    assert isinstance(h, int), 'hash should return an int'
+except RecursionError:
+    pass  # acceptable if depth guard triggers
+
+# === Deep tuple as dict key (triggers hash) ===
+z = (1,)
+for _ in range(10000):
+    z = (z,)
+
+d = {}
+try:
+    d[z] = 'value'
+except RecursionError:
+    pass  # acceptable if depth guard triggers
+
+# === Deep tuple as set element (triggers hash) ===
+w = (1,)
+for _ in range(10000):
+    w = (w,)
+
+s = set()
+try:
+    s.add(w)
+except RecursionError:
+    pass  # acceptable if depth guard triggers

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

@@ -0,0 +1,12 @@
+# Test that deeply nested lists don't crash during repr()
+# Monty truncates with "..." at depth limit, CPython handles in C code
+x = []
+for _ in range(200):
+    x = [x]
+
+# Should not crash - either returns full repr or truncated with "..."
+result = repr(x)
+assert isinstance(result, str), 'repr should return a string'
+assert result.startswith('['), 'repr should start with ['
+# Either full repr or truncated
+assert result.endswith(']') or '...' in result, 'repr should end with ] or contain ...'

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

@@ -0,0 +1,13 @@
+# Test that recursive function calls hit the recursion limit
+# This uses Python function call recursion which both CPython and Monty limit
+
+
+def recurse(n):
+    if n == 0:
+        return 0
+    return recurse(n - 1) + 1
+
+
+# This should raise RecursionError in both interpreters
+recurse(2000)
+# Raise=RecursionError('maximum recursion depth exceeded')

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

@@ -0,0 +1,18 @@
+# Mutual reference cycle: a contains b, b contains a
+# This creates a cycle where:
+#   - a has refcount 2 (variable 'a' + being inside b)
+#   - b has refcount 2 (variable 'b' + being inside a)
+# Without cycle detection, when both variables go out of scope:
+#   - a's refcount drops to 1 (still in b)
+#   - b's refcount drops to 1 (still in a)
+#   - Neither reaches 0, neither is freed (memory leak)
+#
+# NOTE: We return len(b) instead of b because repr(b) would cause infinite
+# recursion / stack overflow (a separate bug - Python handles this by printing [...]
+# for cyclic references)
+a = []
+b = []
+a.append(b)
+b.append(a)
+len(b)
+# ref-counts={'a': 2, 'b': 2}

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

@@ -0,0 +1,12 @@
+# Self-referential list: a contains itself
+# This creates a cycle where a's refcount is 2 (variable + self-reference)
+# Without cycle detection, when 'a' goes out of scope, refcount drops to 1
+# but the object is never freed (memory leak)
+#
+# NOTE: We return len(a) instead of a because repr(a) would cause infinite
+# recursion / stack overflow (a separate bug - Python handles this by printing [...]
+# for cyclic references)
+a = []
+a.append(a)
+len(a)
+# ref-counts={'a': 2}

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

@@ -0,0 +1,5 @@
+k = 'key'
+v = [1, 2]
+d = {k: v}
+d
+# ref-counts={'v': 2, 'd': 2}

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

@@ -0,0 +1,5 @@
+v = [1, 2]
+d = {0: v}
+x = d[0]
+x
+# ref-counts={'v': 4, 'd': 1, 'x': 4}

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

@@ -0,0 +1,14 @@
+inner = ('x',)
+wrapped = (inner,)
+empty = []
+rhs = [wrapped, empty]
+
+try:
+    {}.keys() & rhs
+    assert False, 'dict_keys intersection should reject unhashable iterable items'
+except TypeError as e:
+    assert str(e) == "cannot use 'list' as a set element (unhashable type: 'list')", (
+        'dict_keys intersection should surface the recoverable set-element hash error'
+    )
+
+# ref-counts={'inner': 2, 'wrapped': 2, 'empty': 2, 'rhs': 1}

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

@@ -0,0 +1,6 @@
+v1 = [1]
+v2 = [2]
+d = {0: v1}
+d[0] = v2
+d
+# ref-counts={'v1': 1, 'v2': 2, 'd': 2}

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

@@ -0,0 +1,16 @@
+# Test that GatherFuture and coroutines are properly cleaned up after gather completes.
+# The strict matching check will fail if the GatherFuture leaks (heap_count > unique_refs).
+import asyncio
+
+
+async def task1():
+    return 1
+
+
+async def task2():
+    return 2
+
+
+result = await asyncio.gather(task1(), task2())  # pyright: ignore
+result
+# ref-counts={'result': 2, 'asyncio': 1}

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

@@ -0,0 +1,18 @@
+# Test that GatherFuture and coroutines are properly cleaned up when a task raises.
+# When one task fails, sibling tasks should be cancelled and all resources freed.
+import asyncio
+
+
+async def task_ok():
+    return 1
+
+
+async def task_fail():
+    raise ValueError('task failed')
+
+
+try:
+    result = await asyncio.gather(task_ok(), task_fail())  # pyright: ignore
+except ValueError:
+    pass
+# ref-counts={'asyncio': 1}

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

@@ -0,0 +1,25 @@
+# Test that nested GatherFuture is properly cleaned up when outer task is cancelled.
+# When one task in an outer gather fails, sibling tasks (including those with inner gathers)
+# should be cancelled and all GatherFutures properly cleaned up.
+import asyncio
+
+
+async def inner_task():
+    return 1
+
+
+async def task_with_inner_gather():
+    # This inner gather should be cancelled when the outer gather fails
+    result = await asyncio.gather(inner_task(), inner_task())
+    return result
+
+
+async def task_fail():
+    raise ValueError('outer task failed')
+
+
+try:
+    result = await asyncio.gather(task_with_inner_gather(), task_fail())  # pyright: ignore
+except ValueError:
+    pass
+# ref-counts={'asyncio': 1}

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

@@ -0,0 +1,4 @@
+x = 42
+y = [1, 2]
+y
+# ref-counts={'y': 2}