Add reference counting test cases

The generated IR is pretty large, so manually verifying that reference
counting works is tedious. Instead, test that everything is freed at
runtime.

Author: JukkaL

mypyc/test-data/run-async.test

@@ -347,3 +347,73 @@ async def sleep(t: float) -> None: ...
 def run(x: object) -> object: ...
 
 [typing fixtures/typing-full.pyi]
+
+[case testRunAsyncRefCounting]
+import asyncio
+import gc
+
+def assert_no_leaks(fn, max_new):
+    asyncio.run(fn())
+    gc.collect()
+    old_objs = gc.get_objects()
+    for i in range(10):
+        asyncio.run(fn())
+    gc.collect()
+    new_objs = gc.get_objects()
+    delta = len(new_objs) - len(old_objs)
+    assert delta <= max_new, delta
+
+async def concat_one(x: str) -> str:
+    return x + "1"
+
+async def foo(n: int) -> str:
+    s = ""
+    while len(s) < n:
+        s = await concat_one(s)
+    return s
+
+def test_trivial() -> None:
+    assert_no_leaks(lambda: foo(1000), 5)
+
+async def make_list(a: list[int]) -> list[int]:
+    await concat_one("foobar")
+    return [a[0]]
+
+async def spill() -> list[int]:
+    a: list[int] = []
+    for i in range(5):
+        a = (await make_list(a + [1])) + a + (await make_list(a + [2]))
+    return a
+
+async def bar(n: int) -> None:
+    for i in range(n):
+        await spill()
+
+def test_spilled() -> None:
+    assert_no_leaks(lambda: bar(100), 2)
+
+async def raise_deep(n: int) -> str:
+    if n == 0:
+        raise TypeError(str(n))
+    else:
+        return await raise_deep(n - 1)
+
+async def maybe_raise(n: int) -> str:
+    if n % 3 == 0:
+        await raise_deep(10)
+    return str(n)
+
+async def exc(n: int) -> list[str]:
+    a = []
+    for i in range(n):
+        try:
+            a.append(str(int()) + await maybe_raise(n))
+        except TypeError:
+            a.append(str(int() + 5))
+    return a
+
+def test_exception() -> None:
+    assert_no_leaks(lambda: exc(100), 2)
+
+[file asyncio/__init__.pyi]
+def run(x: object) -> object: ...