simpligy logic and edit docs

Author: iritkatriel

Doc/whatsnew/3.16.rst

@@ -499,8 +499,12 @@ symtable
   (Contributed by Serhiy Storchaka in :gh:`153844`.)
 
 * Inlined list, set and dict comprehensions (:pep:`709`) are now represented
-  as their own symbol tables, of type
-  :attr:`~symtable.SymbolTableType.INLINED_COMPREHENSION`.
+  as their own symbol table entries, of type
+  :attr:`~symtable.SymbolTableType.INLINED_COMPREHENSION`. This entry type
+  represents a sub-scope, and holds information only on the symbols whose
+  scopes are different in the comprehension and the enclosing scope.
+  Sub-scopes are a new mechanism that can be used when a symbol's scope
+  changes within the same compilation unit.
   (Contributed by Irit Katriel in :gh:`124697`.)
 
 

Include/internal/pycore_compile.h

@@ -181,10 +181,10 @@ typedef struct {
     PySTEntryObject *saved_ste;
 } _PyCompile_InlinedComprehensionState;
 
-int _PyCompile_EnterInlinedComprehensionScope(struct _PyCompiler *c, _Py_SourceLocation loc,
+int _PyCompile_EnterInlinedComprehensionScope(struct _PyCompiler *c,
                                               PySTEntryObject *entry,
                                               _PyCompile_InlinedComprehensionState *state);
-int _PyCompile_ExitInlinedComprehensionScope(struct _PyCompiler *c, _Py_SourceLocation loc,
+int _PyCompile_ExitInlinedComprehensionScope(struct _PyCompiler *c,
                                              _PyCompile_InlinedComprehensionState *state);
 int _PyCompile_AddDeferredAnnotation(struct _PyCompiler *c, stmt_ty s,
                                      PyObject **conditional_annotation_index);

Misc/NEWS.d/next/Library/2026-09-02-12-11-00.gh-issue-124697.sUbScp.rst

@@ -1,3 +1,3 @@
 The :mod:`symtable` module now represents inlined list, set and dict
-comprehensions (:pep:`709`) as their own symbol tables, of type
+comprehensions (:pep:`709`) as their own symbol table entries of type
 :attr:`~symtable.SymbolTableType.INLINED_COMPREHENSION`.

Python/codegen.c

@@ -4982,7 +4982,7 @@ push_inlined_comprehension_state(compiler *c, location loc,
                                  _PyCompile_InlinedComprehensionState *state)
 {
     RETURN_IF_ERROR(
-        _PyCompile_EnterInlinedComprehensionScope(c, loc, comp, state));
+        _PyCompile_EnterInlinedComprehensionScope(c, comp, state));
     RETURN_IF_ERROR(
         codegen_push_inlined_comprehension_locals(c, loc, comp, state));
     return SUCCESS;
@@ -5040,7 +5040,7 @@ pop_inlined_comprehension_state(compiler *c, location loc,
                                 _PyCompile_InlinedComprehensionState *state)
 {
     RETURN_IF_ERROR(codegen_pop_inlined_comprehension_locals(c, loc, state));
-    RETURN_IF_ERROR(_PyCompile_ExitInlinedComprehensionScope(c, loc, state));
+    RETURN_IF_ERROR(_PyCompile_ExitInlinedComprehensionScope(c, state));
     return SUCCESS;
 }
 

Python/compile.c

@@ -1018,10 +1018,6 @@ _PyCompile_ResolveNameop(compiler *c, PyObject *mangled, int scope,
 
     PySTEntryObject *ste = c->u->u_ste;
     assert(ste != NULL);
-    while (ste->ste_parent != NULL) {
-        assert(ste->ste_type == InlinedComprehensionBlock);
-        ste = ste->ste_parent;
-    }
 
     assert(scope >= 0);
     switch (scope) {
@@ -1034,15 +1030,24 @@ _PyCompile_ResolveNameop(compiler *c, PyObject *mangled, int scope,
         *optype = COMPILE_OP_DEREF;
         break;
     case LOCAL:
-        if (_PyST_IsFunctionLike(ste) || c->u->u_ste->ste_type == InlinedComprehensionBlock) {
+        /* Inlined comprehensions isolate their locals as FAST, even when
+         * nested in class or module scope. */
+        if (_PyST_IsFunctionLike(ste) || ste->ste_type == InlinedComprehensionBlock) {
             *optype = COMPILE_OP_FAST;
         }
         break;
-    case GLOBAL_IMPLICIT:
-        if (_PyST_IsFunctionLike(ste)) {
+    case GLOBAL_IMPLICIT: {
+        /* Opcode depends on the enclosing non-inlined scope. */
+        PySTEntryObject *enclosing = ste;
+        while (enclosing->ste_parent != NULL) {
+            assert(enclosing->ste_type == InlinedComprehensionBlock);
+            enclosing = enclosing->ste_parent;
+        }
+        if (_PyST_IsFunctionLike(enclosing)) {
             *optype = COMPILE_OP_GLOBAL;
         }
         break;
+    }
     case GLOBAL_EXPLICIT:
         *optype = COMPILE_OP_GLOBAL;
         break;
@@ -1058,8 +1063,7 @@ _PyCompile_ResolveNameop(compiler *c, PyObject *mangled, int scope,
 }
 
 int
-_PyCompile_EnterInlinedComprehensionScope(compiler *c, location loc,
-                                          PySTEntryObject *entry,
+_PyCompile_EnterInlinedComprehensionScope(compiler *c, PySTEntryObject *entry,
                                           _PyCompile_InlinedComprehensionState *state)
 {
     assert(state->saved_ste == NULL);
@@ -1069,8 +1073,8 @@ _PyCompile_EnterInlinedComprehensionScope(compiler *c, location loc,
 }
 
 int
-_PyCompile_ExitInlinedComprehensionScope(compiler *c, location loc,
-                                         _PyCompile_InlinedComprehensionState *state)
+_PyCompile_ExitInlinedComprehensionScope(compiler *c,
+                                        _PyCompile_InlinedComprehensionState *state)
 {
     assert(state->saved_ste != NULL);
     Py_DECREF(c->u->u_ste);