more tests

Author: iritkatriel

Lib/test/test_builtin.py

@@ -545,6 +545,7 @@ async def sleep(delay, result=None):
             '''a = [await sleep(0, 1) for _ in [0]][0]''',
             '''a = {await sleep(0, 1) for _ in [0]}.pop()''',
             '''a = {0: await sleep(0, 1) for _ in [0]}[0]''',
+            '''a = (lambda x=[await sleep(0, 1) for _ in [0]]: x)()[0]''',
             # gh-121637: Make sure we correctly handle the case where the
             # async code is optimized away
             '''assert not await sleep(0); a = 1''',
@@ -624,6 +625,15 @@ async def __aexit__(self, *exc_info):
                    class C:
                        [await x for x in y]
             ''',
+            '''lambda: [await x for x in y]''',
+            '''class C:
+                   def f(self, x=[await y for y in z]):
+                       pass
+            ''',
+            '''type T = [await x for x in y]''',
+            '''async def f[T=[await x for x in y]]():
+                   pass
+            ''',
         ]
         for mode, code_sample in product(modes, code_samples):
             source = dedent(code_sample)

Lib/test/test_coroutines.py

@@ -1,3 +1,4 @@
+import ast
 import contextlib
 import copy
 import inspect
@@ -418,17 +419,26 @@ def test_async_comprehension_scope(self):
             "async def f():\n    {x async for x in y}",
             "async def f():\n    {k: x async for k, x in y}",
             "async def f():\n    [[await x for x in y] for y in z]",
+            # Defaults and bases are evaluated in the enclosing scope.
+            "async def outer():\n    async def f(x=[await y for y in z]): pass",
+            "async def f():\n    class C([await x for x in y]): pass",
         ]
         for code in allowed:
             with self.subTest(code=code):
                 compile(code, "<test>", "exec")
 
         # Generator expressions with await are async genexps and may appear
-        # outside async functions.
+        # outside async functions. A listcomp nested in a genexp is also
+        # allowed (the genexp becomes an async generator).
         for code in [
             "(await x for x in y)",
             "def f():\n    (await x for x in y)",
             "class C:\n    (await x for x in y)",
+            "lambda: (await x for x in y)",
+            "([await x for x in y] for y in z)",
+            "def f():\n    ([await x for x in y] for y in z)",
+            "class C:\n    ([await x for x in y] for y in z)",
+            "async def f():\n    ([await x for x in y] for y in z)",
         ]:
             with self.subTest(code=code):
                 compile(code, "<test>", "exec")
@@ -453,6 +463,22 @@ def test_async_comprehension_scope(self):
             "class C:\n    [[await x for x in y] for y in z]",
             "async def f():\n    class C:\n        x = [await y for y in z]",
             "async def f():\n    class C:\n        x = [y async for y in z]",
+            # Lambdas are never async, even inside async def.
+            "lambda: [await x for x in y]",
+            "async def f():\n    lambda: [await x for x in y]",
+            "class C:\n    f = lambda: [await x for x in y]",
+            # Defaults and bases run in the enclosing scope.
+            "async def f(x=[await y for y in z]): pass",
+            "def f(x=[await y for y in z]): pass",
+            "class C:\n    def f(self, x=[await y for y in z]): pass",
+            "class C([await x for x in y]): pass",
+            # Type aliases and type-parameter scopes.
+            "type T = [await x for x in y]",
+            "type T = [x async for x in y]",
+            "def f[T=[await x for x in y]](): pass",
+            "def f[T: [await x for x in y]](): pass",
+            "async def f[T=[await x for x in y]](): pass",
+            "async def f(x: [await y for y in z]): pass",
         ]
         for code in invalid:
             with self.subTest(code=code):
@@ -465,6 +491,26 @@ def test_async_comprehension_scope(self):
         support.check_syntax_error(
             self, "def f():\n    await x", "'await' outside async function")
 
+        flags = ast.PyCF_ALLOW_TOP_LEVEL_AWAIT
+        for code in [
+            "[await x for x in y]",
+            "async def f(x=[await y for y in z]): pass",
+            "class C([await x for x in y]): pass",
+            "f'{[await x for x in y]}'",
+        ]:
+            with self.subTest(code=code, tla=True):
+                compile(code, "<test>", "exec", flags=flags)
+        still_invalid = [
+            "lambda: [await x for x in y]",
+            "class C:\n    def f(self, x=[await y for y in z]): pass",
+            "type T = [await x for x in y]",
+            "async def f[T=[await x for x in y]](): pass",
+        ]
+        for code in still_invalid:
+            with self.subTest(code=code, tla=True):
+                with self.assertRaisesRegex(SyntaxError, err):
+                    compile(code, "<test>", "exec", flags=flags)
+
     def test_badsyntax_2(self):
         samples = [
             """def foo():