python
diff --git a/‎Include/symtable.h
Copy file name to clipboardExpand all lines: Include/symtable.h
+2Lines changed: 2 additions & 0 deletions b/‎Include/symtable.h
Copy file name to clipboardExpand all lines: Include/symtable.h
+2Lines changed: 2 additions & 0 deletions
diff --git a/‎Python/compile.c
Copy file name to clipboardExpand all lines: Python/compile.c
+28-2Lines changed: 28 additions & 2 deletions b/‎Python/compile.c
Copy file name to clipboardExpand all lines: Python/compile.c
+28-2Lines changed: 28 additions & 2 deletions
diff --git a/‎Python/symtable.c
Copy file name to clipboardExpand all lines: Python/symtable.c
+22Lines changed: 22 additions & 0 deletions b/‎Python/symtable.c
Copy file name to clipboardExpand all lines: Python/symtable.c
+22Lines changed: 22 additions & 0 deletions
@@ -42,6 +42,7 @@ typedef struct _symtable_entry {
     PyObject *ste_varnames;  /* list of function parameters */
     PyObject *ste_children;  /* list of child blocks */
     PyObject *ste_directives;/* locations of global and nonlocal statements */
+    PyObject *ste_classsyms; /* ste_symbols for the surrounding class of a comprehension */
     _Py_block_ty ste_type;   /* module, class, or function */
     int ste_nested;      /* true if block is nested */
     unsigned ste_free : 1;        /* true if block has free variables */
@@ -92,6 +93,7 @@ PyAPI_FUNC(void) PySymtable_Free(struct symtable *);
 #define DEF_FREE_CLASS 2<<5    /* free variable from class's method */
 #define DEF_IMPORT 2<<6        /* assignment occurred via import */
 #define DEF_ANNOT 2<<7         /* this name is annotated */
+#define DEF_EARLYBIND 2<<8     /* name requires early binding semantics (via function args) */
 
 #define DEF_BOUND (DEF_LOCAL | DEF_PARAM | DEF_IMPORT)
 
 
@@ -3886,10 +3886,12 @@ compiler_sync_comprehension_generator(struct compiler *c,
         return 0;
 
     gen = (comprehension_ty)asdl_seq_GET(generators, gen_index);
-
     if (gen_index == 0) {
         /* Receive outermost iter as an implicit argument */
         c->u->u_argcount = 1;
+        /* In some cases, receive additional arguments */
+        if (c->u->u_ste->ste_classsyms)
+            c->u->u_argcount = PyList_Size(c->u->u_ste->ste_varnames);
         ADDOP_I(c, LOAD_FAST, 0);
     }
     else {
@@ -4106,6 +4108,13 @@ compiler_comprehension(struct compiler *c, expr_ty e, int type,
     co = assemble(c, 1);
     qualname = c->u->u_qualname;
     Py_INCREF(qualname);
+    Py_ssize_t args = 1;
+    PyObject *varnames = NULL, *symbols = NULL;
+    if (c->u->u_ste->ste_classsyms) {
+        args = c->u->u_argcount;
+        varnames = c->u->u_ste->ste_varnames; Py_INCREF(varnames);
+        symbols = c->u->u_ste->ste_symbols; Py_INCREF(symbols);
+    }
     compiler_exit_scope(c);
     if (co == NULL)
         goto error;
@@ -4123,7 +4132,24 @@ compiler_comprehension(struct compiler *c, expr_ty e, int type,
         ADDOP(c, GET_ITER);
     }
 
-    ADDOP_I(c, CALL_FUNCTION, 1);
+    /* Load up the early-bound names */
+    if (varnames) {
+        Py_ssize_t sz = PyList_Size(varnames);
+        Py_ssize_t i;
+        for (i = 1; i < sz; ++i) {
+            PyObject *name = PyList_GetItem(varnames, i);
+            PyObject *v = PyDict_GetItem(symbols, name);
+            long flags = 0; if (v) flags = PyLong_AS_LONG(v);
+            if (flags & DEF_EARLYBIND)
+                compiler_nameop(c, name, Load);
+            else
+                ADDOP_O(c, LOAD_CONST, Py_None, consts);
+        }
+    }
+    else args = 1;
+    Py_XDECREF(varnames); Py_XDECREF(symbols);
+
+    ADDOP_I(c, CALL_FUNCTION, args);
 
     if (is_async_generator && type != COMP_GENEXP) {
         ADDOP(c, GET_AWAITABLE);
 
@@ -59,6 +59,7 @@ ste_new(struct symtable *st, identifier name, _Py_block_ty block,
     ste->ste_symbols = NULL;
     ste->ste_varnames = NULL;
     ste->ste_children = NULL;
+    ste->ste_classsyms = NULL;
 
     ste->ste_directives = NULL;
 
@@ -1484,6 +1485,21 @@ symtable_visit_expr(struct symtable *st, expr_ty e)
         VISIT(st, expr, e->v.Starred.value);
         break;
     case Name_kind:
+        if (e->v.Name.ctx == Load && st->st_cur->ste_classsyms) {
+            long localflags = 0, classflags = 0;
+            PyObject *v = PyDict_GetItem(st->st_cur->ste_symbols, e->v.Name.id);
+            if (v) localflags = PyLong_AsLong(v);
+            v = PyDict_GetItem(st->st_cur->ste_classsyms, e->v.Name.id);
+            if (v) classflags = PyLong_AsLong(v);
+            /* If the name has not (yet) been assigned to in this scope, AND it
+            has been assigned to in the surrounding scope, flag it Early Bind. */
+            if (!(localflags & DEF_LOCAL) && (classflags & DEF_LOCAL)) {
+                PyObject *val = PyLong_FromLong(localflags | DEF_PARAM | DEF_EARLYBIND);
+                PyDict_SetItem(st->st_cur->ste_symbols, e->v.Name.id, val);
+                Py_DECREF(val);
+                PyList_Append(st->st_cur->ste_varnames, e->v.Name.id);
+            }
+        }
         if (!symtable_add_def(st, e->v.Name.id,
                               e->v.Name.ctx == Load ? USE : DEF_LOCAL))
             VISIT_QUIT(st, 0);
@@ -1710,6 +1726,11 @@ symtable_handle_comprehension(struct symtable *st, expr_ty e,
     int is_generator = (e->kind == GeneratorExp_kind);
     comprehension_ty outermost = ((comprehension_ty)
                                     asdl_seq_GET(generators, 0));
+    PyObject *classsyms = NULL;
+    if (st->st_cur->ste_type == ClassBlock) {
+        /* Flag this as a comprehension in a class, with potential for early binding */
+        classsyms = st->st_cur->ste_symbols;
+    }
     /* Outermost iterator is evaluated in current scope */
     VISIT(st, expr, outermost->iter);
     /* Create comprehension scope for the rest */
@@ -1718,6 +1739,7 @@ symtable_handle_comprehension(struct symtable *st, expr_ty e,
                               e->lineno, e->col_offset)) {
         return 0;
     }
+    st->st_cur->ste_classsyms = classsyms;
     if (outermost->is_async) {
         st->st_cur->ste_coroutine = 1;
     }