Mark class __conditional_annotations__ as a CELL in the symtable

Stop cooking that cell in the compiler; modules keep it as an
implicit global in the module dict so rebinding still works.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: iritkatriel

Lib/test/test_dis.py

@@ -382,36 +382,34 @@ def wrap_func_w_kwargs():
 # leading newline is for a reason (tests lineno)
 
 dis_annot_stmt_str = """\
-  --           MAKE_CELL                0 (__conditional_annotations__)
-
-   0           RESUME                   0
+  0           RESUME                   0
 
-   2           LOAD_CONST               1 (<code object __annotate__ at 0x..., file "<dis>", line 2>)
-               MAKE_FUNCTION
-               STORE_NAME               4 (__annotate__)
-               BUILD_SET                0
-               STORE_NAME               0 (__conditional_annotations__)
-               LOAD_SMALL_INT           1
-               STORE_NAME               1 (x)
-               LOAD_NAME                0 (__conditional_annotations__)
-               LOAD_SMALL_INT           0
-               CALL_INTRINSIC_2         6 (INTRINSIC_ADD_CONDITIONAL_ANNOTATION)
-               POP_TOP
+  2           LOAD_CONST               1 (<code object __annotate__ at 0x..., file "<dis>", line 2>)
+              MAKE_FUNCTION
+              STORE_NAME               4 (__annotate__)
+              BUILD_SET                0
+              STORE_NAME               0 (__conditional_annotations__)
+              LOAD_SMALL_INT           1
+              STORE_NAME               1 (x)
+              LOAD_NAME                0 (__conditional_annotations__)
+              LOAD_SMALL_INT           0
+              CALL_INTRINSIC_2         6 (INTRINSIC_ADD_CONDITIONAL_ANNOTATION)
+              POP_TOP
 
-   3           LOAD_NAME                0 (__conditional_annotations__)
-               LOAD_SMALL_INT           1
-               CALL_INTRINSIC_2         6 (INTRINSIC_ADD_CONDITIONAL_ANNOTATION)
-               POP_TOP
+  3           LOAD_NAME                0 (__conditional_annotations__)
+              LOAD_SMALL_INT           1
+              CALL_INTRINSIC_2         6 (INTRINSIC_ADD_CONDITIONAL_ANNOTATION)
+              POP_TOP
 
-   4           LOAD_SMALL_INT           1
-               LOAD_NAME                2 (lst)
-               LOAD_NAME                3 (fun)
-               PUSH_NULL
-               LOAD_SMALL_INT           0
-               CALL                     1
-               STORE_SUBSCR
-               LOAD_COMMON_CONSTANT     7 (None)
-               RETURN_VALUE
+  4           LOAD_SMALL_INT           1
+              LOAD_NAME                2 (lst)
+              LOAD_NAME                3 (fun)
+              PUSH_NULL
+              LOAD_SMALL_INT           0
+              CALL                     1
+              STORE_SUBSCR
+              LOAD_COMMON_CONSTANT     7 (None)
+              RETURN_VALUE
 """
 
 fn_with_annotate_str = """

Lib/test/test_super.py

@@ -229,12 +229,9 @@ def method(self):
                           if isinstance(c, types.CodeType) and c.co_name == "outer")
         class_code = next(c for c in outer_code.co_consts
                           if isinstance(c, types.CodeType) and c.co_name == "C")
-        self.assertIn("__classcell__", class_code.co_cellvars)
-        self.assertNotIn("__class__", class_code.co_cellvars)
-        self.assertIn("__class__", class_code.co_freevars)
-        localsplus = (class_code.co_varnames + class_code.co_cellvars
-                      + class_code.co_freevars)
-        self.assertEqual(len(set(localsplus)), len(localsplus))
+        self.assertEqual(class_code.co_cellvars,
+                         ('__classcell__', '__classdictcell__'))
+        self.assertEqual(class_code.co_freevars, ('__class__',))
 
     def test_class_cell_distinct_from_inlined_comp_cell(self):
         # Private __classcell__ coexists with an inlined-comp cell named
@@ -259,8 +256,8 @@ def test_class_cell_distinct_from_inlined_comp_cell(self):
             "    lambdas = [lambda: __class__ for __class__ in (1, 2)]\n",
             "<test>", "exec").co_consts
             if isinstance(c, types.CodeType) and c.co_name == "C")
-        self.assertIn("__classcell__", class_code.co_cellvars)
-        self.assertIn("__class__", class_code.co_cellvars)
+        self.assertEqual(class_code.co_cellvars,
+                         ('__class__', '__classcell__', '__classdictcell__'))
 
     def test___classcell___expected_behaviour(self):
         # See issue #23722

Python/compile.c

@@ -722,17 +722,6 @@ _PyCompile_EnterScope(compiler *c, identifier name, int scope_type,
             return ERROR;
         }
     }
-    if (u->u_ste->ste_has_conditional_annotations) {
-        /* Cook up an implicit __conditional_annotations__ cell */
-        Py_ssize_t res;
-        assert(u->u_scope_type == COMPILE_SCOPE_CLASS || u->u_scope_type == COMPILE_SCOPE_MODULE);
-        res = _PyCompile_DictAddObj(u->u_metadata.u_cellvars, &_Py_ID(__conditional_annotations__));
-        if (res < 0) {
-            compiler_unit_free(u);
-            return ERROR;
-        }
-    }
-
     u->u_metadata.u_freevars = dictbytype(u->u_ste->ste_symbols, FREE, DEF_FREE_CLASS,
                                PyDict_GET_SIZE(u->u_metadata.u_cellvars));
     if (!u->u_metadata.u_freevars) {
@@ -1001,6 +990,15 @@ compiler_resolve_inlined_free(PySTEntryObject **ste, PyObject *name)
         assert(parent != NULL);
         if (parent->ste_type == ClassBlock) {
             if (_PyST_IsClassClosureName(name)) {
+                /* __conditional_annotations__ is a real CELL on the class;
+                 * other class-closure names (__class__, ...) are cooked
+                 * under private cellvar names and are not in ste_symbols. */
+                int parent_scope = _PyST_GetScope(parent, name);
+                RETURN_IF_ERROR(parent_scope);
+                if (parent_scope == CELL) {
+                    *ste = parent;
+                    return CELL;
+                }
                 return GLOBAL_IMPLICIT;
             }
             break;
@@ -1024,24 +1022,12 @@ compiler_class_closure_cellvar(PyObject *name)
     if (name == &_Py_ID(__classdict__)) {
         return &_Py_ID(__classdictcell__);
     }
-    if (name == &_Py_ID(__conditional_annotations__)) {
-        return &_Py_ID(__conditional_annotations__);
-    }
     return NULL;
 }
 
 int
 _PyCompile_GetRefType(compiler *c, PyObject *name)
 {
-    /* Synthetic cells cooked into u_cellvars under their public spelling
-     * (today only __conditional_annotations__) are not always in ste_symbols. */
-    if (c->u->u_scope_type == COMPILE_SCOPE_CLASS ||
-        c->u->u_scope_type == COMPILE_SCOPE_MODULE) {
-        PyObject *cell_name = compiler_class_closure_cellvar(name);
-        if (cell_name != NULL && cell_name == name) {
-            return CELL;
-        }
-    }
     PySTEntryObject *ste = c->u->u_ste;
     int scope = compiler_resolve_inlined_free(&ste, name);
     RETURN_IF_ERROR(scope);
@@ -1081,9 +1067,9 @@ int
 _PyCompile_LookupArg(compiler *c, PyCodeObject *co, PyObject *name)
 {
     /* Class units store the synthetic class-closure cell under a private
-     * name (__classcell__, ...). Inside an inlined comprehension, a nested
-     * free of the public name usually captures that comprehension's CELL;
-     * elsewhere (methods, class-body lambdas) it is the private cell. */
+     * name (__classcell__, ...). Map a free of the public name to that
+     * private cell, except in an inlined comprehension that already has
+     * its own CELL under the public name — prefer that slot. */
     if (c->u->u_scope_type == COMPILE_SCOPE_CLASS) {
         PyObject *cell_name = compiler_class_closure_cellvar(name);
         if (cell_name != NULL) {

Python/symtable.c

@@ -1339,6 +1339,36 @@ analyze_block(PySTEntryObject *ste, PyObject *bound, PyObject *free,
     else if (ste->ste_type == ClassBlock && !drop_class_free(ste, newfree)) {
         goto error;
     }
+    /* Class scopes skip analyze_cells(); ensure the deferred-annotation
+     * name is a CELL (it may appear only via drop_class_free()). Modules
+     * keep it as an implicit global in the module dict. */
+    if (ste->ste_has_conditional_annotations && ste->ste_type == ClassBlock) {
+        PyObject *name = &_Py_ID(__conditional_annotations__);
+        int contains = PyDict_Contains(ste->ste_symbols, name);
+        if (contains < 0) {
+            goto error;
+        }
+        if (!contains) {
+            PyObject *flags = PyLong_FromLong(DEF_LOCAL);
+            if (flags == NULL) {
+                goto error;
+            }
+            int rc = PyDict_SetItem(ste->ste_symbols, name, flags);
+            Py_DECREF(flags);
+            if (rc < 0) {
+                goto error;
+            }
+        }
+        PyObject *v_cell = PyLong_FromLong(CELL);
+        if (v_cell == NULL) {
+            goto error;
+        }
+        int rc = PyDict_SetItem(scopes, name, v_cell);
+        Py_DECREF(v_cell);
+        if (rc < 0) {
+            goto error;
+        }
+    }
     /* Records the results of the analysis in the symbol table entry */
     if (!update_symbols(ste->ste_symbols, scopes, bound, newfree,
                         (ste->ste_type == ClassBlock) || ste->ste_can_see_class_scope))
@@ -2879,7 +2909,12 @@ symtable_visit_annotation(struct symtable *st, expr_ty annotation, void *key)
             && !st->st_cur->ste_has_conditional_annotations)
     {
         st->st_cur->ste_has_conditional_annotations = 1;
-        if (!symtable_add_def(st, &_Py_ID(__conditional_annotations__), USE, LOCATION(annotation))) {
+        /* Class: local binding, promoted to CELL in analyze_block.
+         * Module: USE only (implicit global); the set lives in the
+         * module dict so user rebinding is visible to the intrinsic. */
+        int flag = (st->st_cur->ste_type == ClassBlock) ? DEF_LOCAL : USE;
+        if (!symtable_add_def(st, &_Py_ID(__conditional_annotations__),
+                              flag, LOCATION(annotation))) {
             return 0;
         }
     }