gh-124697: Represent inlined comprehensions as subscopes in the symbol table - #156819

I think if we do this, we should apply the same deduplication to items(), values(), and __len__(). With the separate comprehension-cell and enclosing-free slots, these now disagree with keys():

import sys

def outer(x):
    def inner():
        return [(lambda: x,
                 len(sys._getframe().f_locals),
                 sys._getframe().f_locals.keys(),
                 sys._getframe().f_locals.items())
                for x in x]
    return inner()[0][1:]

print(outer([1, 2]))

Main returns (1, ['x'], [('x', 1)]); this revision returns (2, ['x'], [('x', 1), ('x', [1, 2])]). values() likewise includes both values, and dict(f_locals.items()) silently selects the enclosing list instead of the iteration value returned by dict(f_locals).

Let's extend the new frame-locals test to check that all of these operations agree.

I think this check now counts an inlined child as needing a real class closure, even though its special-name references compile as global lookups.

For example:

class Meta(type):
    def __new__(mcls, name, bases, ns):
        ns.pop('__classcell__', None)
        return type.__new__(mcls, name, bases, ns)

class C(metaclass=Meta):
    result = [[super for _ in (0,)] for _ in (0,)]

Main creates C without supplying a __classcell__. This PR adds the cell and raises RuntimeError: __class__ not set defining 'C'. A single comprehension still succeeds.

Can we traverse through inlined children to determine whether an actual nested compilation unit needs the cell?

Can we preserve the fast-local optimization when a variable is only referenced by other inlined comprehensions?

def f(n):
    return [[x for _ in range(20)] for x in range(20)]

Deferring finalization until the enclosing scope is no longer inlined lets analyze_cells() promote x before those references are handled. Main has no cells or dereference instructions here; this revision has co_cellvars == ('x',), two MAKE_CELL instructions, and STORE_DEREF/LOAD_DEREF.

Small timeit measurements on matching debug builds showed this case around 11–17% slower. I haven't measured release-build impact.

Maybe this is fine? But it seems like it should be possible to keep this refactor behavior-preserving.

Nit: could we add .. versionadded:: 3.16 to this member? The enclosing enum is documented as introduced in 3.13, so the new member's availability is otherwise unclear.

Could we account for the implicit receiver synthesized by load_args_for_super() here? Its scope is 0 in the comprehension's symbol table, so this scope == FREE condition skips the enclosing-scope lookup.

This now aborts compilation in a debug build:

class A:
    def f(self):
        return 42

class B(A):
    def f(self):
        return [super().f() for _ in (0,)]

print(B().f())

Main returns [42]. The implicit receiver load passes self to codegen_nameop(), but self isn't explicitly referenced in the comprehension, so it has no symbol-table entry there. The unresolved scope reaches codegen_nameop()'s assertion. Renaming the receiver to _self gets past the assertion but raises SystemError: no locals found at runtime.