handle symbols which do not exist in an inlined comprehension's symtable entry

Author: iritkatriel

Include/internal/pycore_compile.h

@@ -151,7 +151,7 @@ PyObject *_PyCompile_MaybeMangle(struct _PyCompiler *c, PyObject *name);
 int _PyCompile_MaybeAddStaticAttributeToClass(struct _PyCompiler *c, expr_ty e);
 int _PyCompile_GetRefType(struct _PyCompiler *c, PyObject *name);
 int _PyCompile_LookupCellvar(struct _PyCompiler *c, PyObject *name);
-int _PyCompile_ResolveNameop(struct _PyCompiler *c, PyObject *mangled, int scope,
+int _PyCompile_ResolveNameop(struct _PyCompiler *c, PyObject *mangled,
                              _PyCompile_optype *optype, Py_ssize_t *arg);
 
 int _PyCompile_IsInteractiveTopLevel(struct _PyCompiler *c);

Lib/test/test_listcomps.py

@@ -165,6 +165,30 @@ def test_references_super(self):
         """
         self._check_in_scopes(code, outputs={"res": [super]})
 
+    def test_zero_arg_super_in_inlined_comprehension(self):
+        class A:
+            def f(self):
+                return 42
+
+        class B(A):
+            def f(self):
+                return [super().f() for _ in (0,)]
+
+            def nested(self):
+                return [[super().f() for _ in (0,)] for _ in (0,)]
+
+            def setcomp(self):
+                return [{super().f() for _ in (0,)}]
+
+            def dictcomp(self):
+                return {0: {1: super().f() for _ in (0,)} for _ in (0,)}
+
+        b = B()
+        self.assertEqual(b.f(), [42])
+        self.assertEqual(b.nested(), [[42]])
+        self.assertEqual(b.setcomp(), [{42}])
+        self.assertEqual(b.dictcomp(), {0: {1: 42}})
+
     def test_references___class__(self):
         code = """
             res = [__class__ for x in [1]]

Python/codegen.c

@@ -3326,21 +3326,14 @@ codegen_nameop(compiler *c, location loc,
         return ERROR;
     }
 
-    int scope = _PyST_GetScope(SYMTABLE_ENTRY(c), mangled);
-    if (scope == -1) {
-        goto error;
-    }
-
     _PyCompile_optype optype;
     Py_ssize_t arg = 0;
-    if (_PyCompile_ResolveNameop(c, mangled, scope, &optype, &arg) < 0) {
+    int scope = _PyCompile_ResolveNameop(c, mangled, &optype, &arg);
+    if (scope < 0) {
         Py_DECREF(mangled);
         return ERROR;
     }
 
-    /* XXX Leave assert here, but handle __doc__ and the like better */
-    assert(scope || PyUnicode_READ_CHAR(name, 0) == '_');
-
     int op = 0;
     switch (optype) {
     case COMPILE_OP_DEREF:

Python/compile.c

@@ -980,15 +980,21 @@ compiler_mod(compiler *c, mod_ty mod)
 }
 
 /* Inlined comprehensions are compiled in the enclosing unit. If a name is
- * FREE in the comprehension, resolve it in enclosing tables until it is no
- * longer FREE. Stop if the next table is a class: nested scopes (including
- * inlined comprehensions) do not see class locals, so the name stays FREE.
- * __class__ and friends are not allowed to be free through a class; treat
- * those loads as implicit globals. */
+ * FREE in the comprehension, or is absent from its table (scope 0), resolve
+ * it in enclosing tables until it is bound. Stop if the next table is a class:
+ * nested scopes (including inlined comprehensions) do not see class locals, so
+ * the name stays FREE. __class__ and friends are not allowed to be free
+ * through a class; treat those loads as implicit globals.
+ *
+ * Names with no entry (scope 0) include loads synthesized by codegen, such as
+ * the implicit receiver for zero-arg super(). */
 static int
-compiler_resolve_inlined_free(PySTEntryObject **ste, int scope, PyObject *name)
+compiler_resolve_inlined_free(PySTEntryObject **ste, PyObject *name)
 {
-    while (scope == FREE && (*ste)->ste_type == InlinedComprehensionBlock) {
+    int scope = _PyST_GetScope(*ste, name);
+    RETURN_IF_ERROR(scope);
+    while ((*ste)->ste_type == InlinedComprehensionBlock &&
+           (scope == FREE || scope == 0)) {
         PySTEntryObject *parent = (*ste)->ste_parent;
         assert(parent != NULL);
         if (parent->ste_type == ClassBlock) {
@@ -1011,9 +1017,7 @@ _PyCompile_GetRefType(compiler *c, PyObject *name)
         return CELL;
     }
     PySTEntryObject *ste = c->u->u_ste;
-    int scope = _PyST_GetScope(ste, name);
-    RETURN_IF_ERROR(scope);
-    scope = compiler_resolve_inlined_free(&ste, scope, name);
+    int scope = compiler_resolve_inlined_free(&ste, name);
     RETURN_IF_ERROR(scope);
     if (scope == 0) {
         PyErr_Format(PyExc_SystemError,
@@ -1104,7 +1108,7 @@ _PyCompile_StaticAttributesAsTuple(compiler *c)
 }
 
 int
-_PyCompile_ResolveNameop(compiler *c, PyObject *mangled, int scope,
+_PyCompile_ResolveNameop(compiler *c, PyObject *mangled,
                           _PyCompile_optype *optype, Py_ssize_t *arg)
 {
     PyObject *dict = c->u->u_metadata.u_names;
@@ -1113,8 +1117,7 @@ _PyCompile_ResolveNameop(compiler *c, PyObject *mangled, int scope,
     PySTEntryObject *ste = c->u->u_ste;
     assert(ste != NULL);
 
-    assert(scope >= 0);
-    scope = compiler_resolve_inlined_free(&ste, scope, mangled);
+    int scope = compiler_resolve_inlined_free(&ste, mangled);
     RETURN_IF_ERROR(scope);
 
     switch (scope) {
@@ -1152,11 +1155,13 @@ _PyCompile_ResolveNameop(compiler *c, PyObject *mangled, int scope,
         /* scope can be 0 */
         break;
     }
+    /* XXX Handle __doc__ and the like better */
+    assert(scope || PyUnicode_READ_CHAR(mangled, 0) == '_');
     if (*optype != COMPILE_OP_FAST) {
         *arg = _PyCompile_DictAddObj(dict, mangled);
         RETURN_IF_ERROR(*arg);
     }
-    return SUCCESS;
+    return scope;
 }
 
 int