[py-compiler] relax async comprehension nesting when inlined

Summary:
In cinder 3.8 we unintentionally allowed async comprehensions to nest
inside non-async ones, due to comprehension inlining. When we ported
comprehension inlining to 3.10, we closed this hole for better fidelity to
upstream compiler behavior, but that means we have to fix the
places in IGSRV that now break this rule. And this doesn't seem worth it
considering the restriction is lifted in Python 3.11 anyway:
python/cpython#6766

This diff just restores the 3.8 behavior of comprehension inlining allowing
async comprehensions nested inside non-async ones.

Facebook: this should unblock 3.10 testing on IGSRV.

Test Plan: Modified test to specify new behavior.

Reviewers: itamaro, emacs, #cinder_porting

Reviewed By: itamaro

Subscribers: mpage, jackyzhang, orvid

Differential Revision: https://phabricator.intern.facebook.com/D39825885

Tags: publish_when_ready, cinder-310-exclusive

Author: Carl Meyer

Lib/compiler/pycodegen.py

@@ -3026,10 +3026,6 @@ class CinderBaseCodeGenerator(CodeGenerator):
 class CinderCodeGenerator(CinderBaseCodeGenerator):
     _SymbolVisitor = symbols.CinderSymbolVisitor
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.inlined_comprehensions = []
-
     def set_qual_name(self, qualname):
         self._qual_name = qualname
 
@@ -3125,24 +3121,6 @@ def compile_comprehension(
         if scope.inlined:
             # for inlined comprehension process with current generator
             gen = self
-            if self.inlined_comprehensions:
-                # Have a parent inlined comprehension; use that
-                is_async_function = self.inlined_comprehensions[-1].coroutine
-            else:
-                # No parent inlined comprehension; use outer function
-                is_async_function = self.scope.coroutine
-            self.inlined_comprehensions.append(scope)
-            is_async_generator = scope.coroutine
-            # TODO also add check for PyCF_ALLOW_TOP_LEVEL_AWAIT
-            if (
-                is_async_generator
-                and not is_async_function
-                and not isinstance(node, ast.GeneratorExp)
-            ):
-                raise self.syntax_error(
-                    "asynchronous comprehension outside of an asynchronous function",
-                    node,
-                )
         else:
             gen = self.make_func_codegen(
                 node, self.conjure_arguments([ast.arg(".0", None)]), name, node.lineno
@@ -3193,9 +3171,6 @@ def compile_comprehension(
             self.emit("LOAD_CONST", None)
             self.emit("YIELD_FROM")
 
-        if scope.inlined:
-            self.inlined_comprehensions.pop()
-
 
 def get_default_generator():
     if "cinder" in sys.version:

Lib/test/test_compiler/test_py310.py

@@ -1,5 +1,10 @@
 import io
 from compiler.dis_stable import Disassembler
+from compiler.pycodegen import (
+    BaseCodeGenerator,
+    CinderCodeGenerator,
+    PythonCodeGenerator,
+)
 from textwrap import dedent
 
 from .common import CompilerTest
@@ -21,13 +26,15 @@ def _check(self, src, optimize=-1):
         expected = dump_code(compile(src, "", mode="exec", optimize=optimize))
         self.assertEqual(actual, expected)
 
-    def _check_error(self, src, msg_contains, *, optimize=-1):
+    def _check_error(
+        self, src, msg_contains, *, optimize=-1, generator=PythonCodeGenerator
+    ):
         src = dedent(src).strip()
         with self.assertRaises(SyntaxError) as ctx:
             compile(src, "", mode="exec", optimize=optimize)
         cmsg = str(ctx.exception.msg)
         with self.assertRaises(SyntaxError) as ctx:
-            self.compile(src, optimize=optimize)
+            self.compile(src, optimize=optimize, generator=generator)
         pymsg = str(ctx.exception.msg)
         self.assertEqual(pymsg, cmsg)
         self.assertIn(pymsg, msg_contains)
@@ -57,6 +64,14 @@ def test_no_nested_async_comprehension(self):
             async def foo(a):
                 return {k: [y for y in k if await bar(y)] for k in a}
         """
+
+        # The base code generator matches 3.10 upstream and thus has this
+        # restriction, but the restriction has been lifted in 3.11
+        # (see https://github.com/python/cpython/pull/6766), so we also lift
+        # it in CinderCodeGenerator.
         self._check_error(
-            codestr, "asynchronous comprehension outside of an asynchronous function"
+            codestr,
+            "asynchronous comprehension outside of an asynchronous function",
+            generator=BaseCodeGenerator,
         )
+        self.compile(codestr, generator=CinderCodeGenerator)