https://github.com/python/cpython/commit/d24d1c986d2c55933f89c6b73b2e618448115f54
commit: d24d1c986d2c55933f89c6b73b2e618448115f54
branch: main
author: Irit Katriel <1055913+iritkatr...@users.noreply.github.com>
committer: iritkatriel <1055913+iritkatr...@users.noreply.github.com>
date: 2024-08-27T16:57:31+01:00
summary:
gh-121404: split compiler_nameop into a codegen part and a compiler part
(#123398)
files:
M Python/compile.c
diff --git a/Python/compile.c b/Python/compile.c
index 3e762aace96f21..3464723104f1b4 100644
--- a/Python/compile.c
+++ b/Python/compile.c
@@ -107,6 +107,7 @@ static int compiler_optimization_level(struct compiler *c);
static int compiler_is_interactive(struct compiler *c);
static int compiler_is_nested_scope(struct compiler *c);
static int compiler_scope_type(struct compiler *c);
+static int compiler_is_in_inlined_comp(struct compiler *c);
static PyObject *compiler_qualname(struct compiler *c);
#define LOCATION(LNO, END_LNO, COL, END_COL) \
@@ -311,7 +312,7 @@ typedef struct {
static void compiler_free(struct compiler *);
static int compiler_error(struct compiler *, location loc, const char *, ...);
static int compiler_warn(struct compiler *, location loc, const char *, ...);
-static int compiler_nameop(struct compiler *, location, identifier,
expr_context_ty);
+static int codegen_nameop(struct compiler *, location, identifier,
expr_context_ty);
static PyCodeObject *compiler_mod(struct compiler *, mod_ty);
static int codegen_visit_stmt(struct compiler *, stmt_ty);
@@ -1419,8 +1420,8 @@ codegen_unwind_fblock(struct compiler *c, location *ploc,
ADDOP(c, *ploc, POP_EXCEPT);
if (info->fb_datum) {
ADDOP_LOAD_CONST(c, *ploc, Py_None);
- RETURN_IF_ERROR(compiler_nameop(c, *ploc, info->fb_datum,
Store));
- RETURN_IF_ERROR(compiler_nameop(c, *ploc, info->fb_datum,
Del));
+ RETURN_IF_ERROR(codegen_nameop(c, *ploc, info->fb_datum,
Store));
+ RETURN_IF_ERROR(codegen_nameop(c, *ploc, info->fb_datum, Del));
}
return SUCCESS;
}
@@ -1553,12 +1554,8 @@ codegen_process_deferred_annotations(struct compiler *c,
location loc)
}
Py_DECREF(deferred_anno);
- RETURN_IF_ERROR(
- codegen_leave_annotations_scope(c, loc, annotations_len)
- );
- RETURN_IF_ERROR(
- compiler_nameop(c, loc, &_Py_ID(__annotate__), Store)
- );
+ RETURN_IF_ERROR(codegen_leave_annotations_scope(c, loc, annotations_len));
+ RETURN_IF_ERROR(codegen_nameop(c, loc, &_Py_ID(__annotate__), Store));
return SUCCESS;
}
@@ -1594,7 +1591,7 @@ codegen_body(struct compiler *c, location loc,
asdl_stmt_seq *stmts)
location loc = LOC(st->v.Expr.value);
ADDOP_LOAD_CONST(c, loc, cleandoc);
Py_DECREF(cleandoc);
- RETURN_IF_ERROR(compiler_nameop(c, NO_LOCATION,
&_Py_ID(__doc__), Store));
+ RETURN_IF_ERROR(codegen_nameop(c, NO_LOCATION,
&_Py_ID(__doc__), Store));
}
}
}
@@ -2109,7 +2106,7 @@ codegen_type_params(struct compiler *c,
asdl_type_param_seq *type_params)
typeparam->v.TypeVar.name);
}
ADDOP_I(c, loc, COPY, 1);
- RETURN_IF_ERROR(compiler_nameop(c, loc, typeparam->v.TypeVar.name,
Store));
+ RETURN_IF_ERROR(codegen_nameop(c, loc, typeparam->v.TypeVar.name,
Store));
break;
case TypeVarTuple_kind:
ADDOP_LOAD_CONST(c, loc, typeparam->v.TypeVarTuple.name);
@@ -2128,7 +2125,7 @@ codegen_type_params(struct compiler *c,
asdl_type_param_seq *type_params)
typeparam->v.TypeVarTuple.name);
}
ADDOP_I(c, loc, COPY, 1);
- RETURN_IF_ERROR(compiler_nameop(c, loc,
typeparam->v.TypeVarTuple.name, Store));
+ RETURN_IF_ERROR(codegen_nameop(c, loc,
typeparam->v.TypeVarTuple.name, Store));
break;
case ParamSpec_kind:
ADDOP_LOAD_CONST(c, loc, typeparam->v.ParamSpec.name);
@@ -2147,7 +2144,7 @@ codegen_type_params(struct compiler *c,
asdl_type_param_seq *type_params)
typeparam->v.ParamSpec.name);
}
ADDOP_I(c, loc, COPY, 1);
- RETURN_IF_ERROR(compiler_nameop(c, loc,
typeparam->v.ParamSpec.name, Store));
+ RETURN_IF_ERROR(codegen_nameop(c, loc,
typeparam->v.ParamSpec.name, Store));
break;
}
}
@@ -2356,15 +2353,15 @@ codegen_function(struct compiler *c, stmt_ty s, int
is_async)
}
RETURN_IF_ERROR(codegen_apply_decorators(c, decos));
- return compiler_nameop(c, loc, name, Store);
+ return codegen_nameop(c, loc, name, Store);
}
static int
codegen_set_type_params_in_class(struct compiler *c, location loc)
{
_Py_DECLARE_STR(type_params, ".type_params");
- RETURN_IF_ERROR(compiler_nameop(c, loc, &_Py_STR(type_params), Load));
- RETURN_IF_ERROR(compiler_nameop(c, loc, &_Py_ID(__type_params__), Store));
+ RETURN_IF_ERROR(codegen_nameop(c, loc, &_Py_STR(type_params), Load));
+ RETURN_IF_ERROR(codegen_nameop(c, loc, &_Py_ID(__type_params__), Store));
return SUCCESS;
}
@@ -2396,13 +2393,13 @@ codegen_class_body(struct compiler *c, stmt_ty s, int
firstlineno)
location loc = LOCATION(firstlineno, firstlineno, 0, 0);
/* load (global) __name__ ... */
- RETURN_IF_ERROR_IN_SCOPE(c, compiler_nameop(c, loc, &_Py_ID(__name__),
Load));
+ RETURN_IF_ERROR_IN_SCOPE(c, codegen_nameop(c, loc, &_Py_ID(__name__),
Load));
/* ... and store it as __module__ */
- RETURN_IF_ERROR_IN_SCOPE(c, compiler_nameop(c, loc, &_Py_ID(__module__),
Store));
+ RETURN_IF_ERROR_IN_SCOPE(c, codegen_nameop(c, loc, &_Py_ID(__module__),
Store));
ADDOP_LOAD_CONST(c, loc, QUALNAME(c));
- RETURN_IF_ERROR_IN_SCOPE(c, compiler_nameop(c, loc, &_Py_ID(__qualname__),
Store));
+ RETURN_IF_ERROR_IN_SCOPE(c, codegen_nameop(c, loc, &_Py_ID(__qualname__),
Store));
ADDOP_LOAD_CONST_NEW(c, loc,
PyLong_FromLong(c->u->u_metadata.u_firstlineno));
- RETURN_IF_ERROR_IN_SCOPE(c, compiler_nameop(c, loc,
&_Py_ID(__firstlineno__), Store));
+ RETURN_IF_ERROR_IN_SCOPE(c, codegen_nameop(c, loc,
&_Py_ID(__firstlineno__), Store));
asdl_type_param_seq *type_params = s->v.ClassDef.type_params;
if (asdl_seq_LEN(type_params) > 0) {
RETURN_IF_ERROR_IN_SCOPE(c, codegen_set_type_params_in_class(c, loc));
@@ -2410,8 +2407,8 @@ codegen_class_body(struct compiler *c, stmt_ty s, int
firstlineno)
if (SYMTABLE_ENTRY(c)->ste_needs_classdict) {
ADDOP(c, loc, LOAD_LOCALS);
- // We can't use compiler_nameop here because we need to generate a
- // STORE_DEREF in a class namespace, and compiler_nameop() won't do
+ // We can't use codegen_nameop here because we need to generate a
+ // STORE_DEREF in a class namespace, and codegen_nameop() won't do
// that by default.
ADDOP_N_IN_SCOPE(c, loc, STORE_DEREF, &_Py_ID(__classdict__),
cellvars);
}
@@ -2425,7 +2422,7 @@ codegen_class_body(struct compiler *c, stmt_ty s, int
firstlineno)
ADDOP_LOAD_CONST(c, NO_LOCATION, static_attributes);
Py_CLEAR(static_attributes);
RETURN_IF_ERROR_IN_SCOPE(
- c, compiler_nameop(c, NO_LOCATION, &_Py_ID(__static_attributes__),
Store));
+ c, codegen_nameop(c, NO_LOCATION, &_Py_ID(__static_attributes__),
Store));
/* The following code is artificial */
/* Set __classdictcell__ if necessary */
if (SYMTABLE_ENTRY(c)->ste_needs_classdict) {
@@ -2434,7 +2431,7 @@ codegen_class_body(struct compiler *c, stmt_ty s, int
firstlineno)
RETURN_IF_ERROR_IN_SCOPE(c, i);
ADDOP_I(c, NO_LOCATION, LOAD_CLOSURE, i);
RETURN_IF_ERROR_IN_SCOPE(
- c, compiler_nameop(c, NO_LOCATION, &_Py_ID(__classdictcell__),
Store));
+ c, codegen_nameop(c, NO_LOCATION, &_Py_ID(__classdictcell__),
Store));
}
/* Return __classcell__ if it is referenced, otherwise return None */
if (SYMTABLE_ENTRY(c)->ste_needs_class_closure) {
@@ -2444,7 +2441,7 @@ codegen_class_body(struct compiler *c, stmt_ty s, int
firstlineno)
ADDOP_I(c, NO_LOCATION, LOAD_CLOSURE, i);
ADDOP_I(c, NO_LOCATION, COPY, 1);
RETURN_IF_ERROR_IN_SCOPE(
- c, compiler_nameop(c, NO_LOCATION, &_Py_ID(__classcell__), Store));
+ c, codegen_nameop(c, NO_LOCATION, &_Py_ID(__classcell__), Store));
}
else {
/* No methods referenced __class__, so just return None */
@@ -2506,7 +2503,7 @@ codegen_class(struct compiler *c, stmt_ty s)
RETURN_IF_ERROR(ret);
RETURN_IF_ERROR_IN_SCOPE(c, codegen_type_params(c, type_params));
_Py_DECLARE_STR(type_params, ".type_params");
- RETURN_IF_ERROR_IN_SCOPE(c, compiler_nameop(c, loc,
&_Py_STR(type_params), Store));
+ RETURN_IF_ERROR_IN_SCOPE(c, codegen_nameop(c, loc,
&_Py_STR(type_params), Store));
}
int ret = codegen_class_body(c, s, firstlineno);
@@ -2522,9 +2519,9 @@ codegen_class(struct compiler *c, stmt_ty s)
if (is_generic) {
_Py_DECLARE_STR(type_params, ".type_params");
_Py_DECLARE_STR(generic_base, ".generic_base");
- RETURN_IF_ERROR_IN_SCOPE(c, compiler_nameop(c, loc,
&_Py_STR(type_params), Load));
+ RETURN_IF_ERROR_IN_SCOPE(c, codegen_nameop(c, loc,
&_Py_STR(type_params), Load));
ADDOP_I_IN_SCOPE(c, loc, CALL_INTRINSIC_1,
INTRINSIC_SUBSCRIPT_GENERIC);
- RETURN_IF_ERROR_IN_SCOPE(c, compiler_nameop(c, loc,
&_Py_STR(generic_base), Store));
+ RETURN_IF_ERROR_IN_SCOPE(c, codegen_nameop(c, loc,
&_Py_STR(generic_base), Store));
Py_ssize_t original_len = asdl_seq_LEN(s->v.ClassDef.bases);
asdl_expr_seq *bases = _Py_asdl_expr_seq_new(
@@ -2570,7 +2567,7 @@ codegen_class(struct compiler *c, stmt_ty s)
RETURN_IF_ERROR(codegen_apply_decorators(c, decos));
/* 7. store into <name> */
- RETURN_IF_ERROR(compiler_nameop(c, loc, s->v.ClassDef.name, Store));
+ RETURN_IF_ERROR(codegen_nameop(c, loc, s->v.ClassDef.name, Store));
return SUCCESS;
}
@@ -2647,7 +2644,7 @@ codegen_typealias(struct compiler *c, stmt_ty s)
ADDOP(c, loc, PUSH_NULL);
ADDOP_I(c, loc, CALL, 0);
}
- RETURN_IF_ERROR(compiler_nameop(c, loc, name, Store));
+ RETURN_IF_ERROR(codegen_nameop(c, loc, name, Store));
return SUCCESS;
}
@@ -3340,7 +3337,7 @@ codegen_try_except(struct compiler *c, stmt_ty s)
NEW_JUMP_TARGET_LABEL(c, cleanup_body);
RETURN_IF_ERROR(
- compiler_nameop(c, loc, handler->v.ExceptHandler.name, Store));
+ codegen_nameop(c, loc, handler->v.ExceptHandler.name, Store));
/*
try:
@@ -3370,9 +3367,9 @@ codegen_try_except(struct compiler *c, stmt_ty s)
ADDOP(c, NO_LOCATION, POP_EXCEPT);
ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None);
RETURN_IF_ERROR(
- compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name,
Store));
+ codegen_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name,
Store));
RETURN_IF_ERROR(
- compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name,
Del));
+ codegen_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name,
Del));
ADDOP_JUMP(c, NO_LOCATION, JUMP_NO_INTERRUPT, end);
/* except: */
@@ -3381,9 +3378,9 @@ codegen_try_except(struct compiler *c, stmt_ty s)
/* name = None; del name; # artificial */
ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None);
RETURN_IF_ERROR(
- compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name,
Store));
+ codegen_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name,
Store));
RETURN_IF_ERROR(
- compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name,
Del));
+ codegen_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name,
Del));
ADDOP_I(c, NO_LOCATION, RERAISE, 1);
}
@@ -3535,7 +3532,7 @@ codegen_try_star_except(struct compiler *c, stmt_ty s)
if (handler->v.ExceptHandler.name) {
RETURN_IF_ERROR(
- compiler_nameop(c, loc, handler->v.ExceptHandler.name, Store));
+ codegen_nameop(c, loc, handler->v.ExceptHandler.name, Store));
}
else {
ADDOP(c, loc, POP_TOP); // match
@@ -3567,9 +3564,9 @@ codegen_try_star_except(struct compiler *c, stmt_ty s)
if (handler->v.ExceptHandler.name) {
ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None);
RETURN_IF_ERROR(
- compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name,
Store));
+ codegen_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name,
Store));
RETURN_IF_ERROR(
- compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name,
Del));
+ codegen_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name,
Del));
}
ADDOP_JUMP(c, NO_LOCATION, JUMP_NO_INTERRUPT, except);
@@ -3580,9 +3577,9 @@ codegen_try_star_except(struct compiler *c, stmt_ty s)
if (handler->v.ExceptHandler.name) {
ADDOP_LOAD_CONST(c, NO_LOCATION, Py_None);
RETURN_IF_ERROR(
- compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name,
Store));
+ codegen_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name,
Store));
RETURN_IF_ERROR(
- compiler_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name,
Del));
+ codegen_nameop(c, NO_LOCATION, handler->v.ExceptHandler.name,
Del));
}
/* add exception raised to the res list */
@@ -3690,11 +3687,11 @@ codegen_import_as(struct compiler *c, location loc,
ADDOP_I(c, loc, SWAP, 2);
ADDOP(c, loc, POP_TOP);
}
- RETURN_IF_ERROR(compiler_nameop(c, loc, asname, Store));
+ RETURN_IF_ERROR(codegen_nameop(c, loc, asname, Store));
ADDOP(c, loc, POP_TOP);
return SUCCESS;
}
- return compiler_nameop(c, loc, asname, Store);
+ return codegen_nameop(c, loc, asname, Store);
}
static int
@@ -3733,7 +3730,7 @@ codegen_import(struct compiler *c, stmt_ty s)
return ERROR;
}
}
- r = compiler_nameop(c, loc, tmp, Store);
+ r = codegen_nameop(c, loc, tmp, Store);
if (dot != -1) {
Py_DECREF(tmp);
}
@@ -3787,7 +3784,7 @@ codegen_from_import(struct compiler *c, stmt_ty s)
store_name = alias->asname;
}
- RETURN_IF_ERROR(compiler_nameop(c, LOC(s), store_name, Store));
+ RETURN_IF_ERROR(codegen_nameop(c, LOC(s), store_name, Store));
}
/* remove imported module */
ADDOP(c, LOC(s), POP_TOP);
@@ -4031,76 +4028,89 @@ codegen_load_classdict_freevar(struct compiler *c,
location loc)
return SUCCESS;
}
+typedef enum { OP_FAST, OP_GLOBAL, OP_DEREF, OP_NAME } compiler_optype;
+
static int
-compiler_nameop(struct compiler *c, location loc,
- identifier name, expr_context_ty ctx)
+compiler_resolve_nameop(struct compiler *c, PyObject *mangled, int scope,
+ compiler_optype *optype, Py_ssize_t *arg)
{
- int op, scope;
- Py_ssize_t arg;
- enum { OP_FAST, OP_GLOBAL, OP_DEREF, OP_NAME } optype;
-
PyObject *dict = c->u->u_metadata.u_names;
- PyObject *mangled;
-
- assert(!_PyUnicode_EqualToASCIIString(name, "None") &&
- !_PyUnicode_EqualToASCIIString(name, "True") &&
- !_PyUnicode_EqualToASCIIString(name, "False"));
-
- mangled = compiler_maybe_mangle(c, name);
- if (!mangled) {
- return ERROR;
- }
+ *optype = OP_NAME;
- op = 0;
- optype = OP_NAME;
- scope = _PyST_GetScope(SYMTABLE_ENTRY(c), mangled);
+ assert(scope >= 0);
switch (scope) {
case FREE:
dict = c->u->u_metadata.u_freevars;
- optype = OP_DEREF;
+ *optype = OP_DEREF;
break;
case CELL:
dict = c->u->u_metadata.u_cellvars;
- optype = OP_DEREF;
+ *optype = OP_DEREF;
break;
case LOCAL:
if (_PyST_IsFunctionLike(SYMTABLE_ENTRY(c))) {
- optype = OP_FAST;
+ *optype = OP_FAST;
}
else {
PyObject *item;
- if (PyDict_GetItemRef(c->u->u_metadata.u_fasthidden, mangled,
- &item) < 0) {
- goto error;
- }
+ RETURN_IF_ERROR(PyDict_GetItemRef(c->u->u_metadata.u_fasthidden,
mangled,
+ &item));
if (item == Py_True) {
- optype = OP_FAST;
+ *optype = OP_FAST;
}
Py_XDECREF(item);
}
break;
case GLOBAL_IMPLICIT:
- if (_PyST_IsFunctionLike(SYMTABLE_ENTRY(c)))
- optype = OP_GLOBAL;
+ if (_PyST_IsFunctionLike(SYMTABLE_ENTRY(c))) {
+ *optype = OP_GLOBAL;
+ }
break;
case GLOBAL_EXPLICIT:
- optype = OP_GLOBAL;
+ *optype = OP_GLOBAL;
break;
- case -1:
- goto error;
default:
/* scope can be 0 */
break;
}
+ if (*optype != OP_FAST) {
+ *arg = dict_add_o(dict, mangled);
+ RETURN_IF_ERROR(*arg);
+ }
+ return SUCCESS;
+}
+
+static int
+codegen_nameop(struct compiler *c, location loc,
+ identifier name, expr_context_ty ctx)
+{
+ assert(!_PyUnicode_EqualToASCIIString(name, "None") &&
+ !_PyUnicode_EqualToASCIIString(name, "True") &&
+ !_PyUnicode_EqualToASCIIString(name, "False"));
+
+ PyObject *mangled = compiler_maybe_mangle(c, name);
+ if (!mangled) {
+ return ERROR;
+ }
+
+ int scope = _PyST_GetScope(SYMTABLE_ENTRY(c), mangled);
+ RETURN_IF_ERROR(scope);
+ compiler_optype optype;
+ Py_ssize_t arg = 0;
+ if (compiler_resolve_nameop(c, mangled, scope, &optype, &arg) < 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 OP_DEREF:
switch (ctx) {
case Load:
- if (SYMTABLE_ENTRY(c)->ste_type == ClassBlock &&
!c->u->u_in_inlined_comp) {
+ if (SYMTABLE_ENTRY(c)->ste_type == ClassBlock &&
!compiler_is_in_inlined_comp(c)) {
op = LOAD_FROM_DICT_OR_DEREF;
// First load the locals
if (codegen_addop_noarg(INSTR_SEQUENCE(c), LOAD_LOCALS, loc) <
0) {
@@ -4151,7 +4161,7 @@ compiler_nameop(struct compiler *c, location loc,
switch (ctx) {
case Load:
op = (SYMTABLE_ENTRY(c)->ste_type == ClassBlock
- && c->u->u_in_inlined_comp)
+ && compiler_is_in_inlined_comp(c))
? LOAD_GLOBAL
: LOAD_NAME;
break;
@@ -4162,11 +4172,7 @@ compiler_nameop(struct compiler *c, location loc,
}
assert(op);
- arg = dict_add_o(dict, mangled);
Py_DECREF(mangled);
- if (arg < 0) {
- return ERROR;
- }
if (op == LOAD_GLOBAL) {
arg <<= 1;
}
@@ -4705,7 +4711,7 @@ load_args_for_super(struct compiler *c, expr_ty e) {
// load super() global
PyObject *super_name = e->v.Call.func->v.Name.id;
- RETURN_IF_ERROR(compiler_nameop(c, LOC(e->v.Call.func), super_name, Load));
+ RETURN_IF_ERROR(codegen_nameop(c, LOC(e->v.Call.func), super_name, Load));
if (asdl_seq_LEN(e->v.Call.args) == 2) {
VISIT(c, expr, asdl_seq_GET(e->v.Call.args, 0));
@@ -4716,7 +4722,7 @@ load_args_for_super(struct compiler *c, expr_ty e) {
// load __class__ cell
PyObject *name = &_Py_ID(__class__);
assert(compiler_get_ref_type(c, name) == FREE);
- RETURN_IF_ERROR(compiler_nameop(c, loc, name, Load));
+ RETURN_IF_ERROR(codegen_nameop(c, loc, name, Load));
// load self (first argument)
Py_ssize_t i = 0;
@@ -4724,7 +4730,7 @@ load_args_for_super(struct compiler *c, expr_ty e) {
if (!PyDict_Next(c->u->u_metadata.u_varnames, &i, &key, &value)) {
return ERROR;
}
- RETURN_IF_ERROR(compiler_nameop(c, loc, key, Load));
+ RETURN_IF_ERROR(codegen_nameop(c, loc, key, Load));
return SUCCESS;
}
@@ -6171,7 +6177,7 @@ codegen_visit_expr(struct compiler *c, expr_ty e)
break;
}
case Name_kind:
- return compiler_nameop(c, loc, e->v.Name.id, e->v.Name.ctx);
+ return codegen_nameop(c, loc, e->v.Name.id, e->v.Name.ctx);
/* child nodes of List and Tuple will have expr_context set */
case List_kind:
return codegen_list(c, e);
@@ -6220,7 +6226,7 @@ codegen_augassign(struct compiler *c, stmt_ty s)
}
break;
case Name_kind:
- RETURN_IF_ERROR(compiler_nameop(c, loc, e->v.Name.id, Load));
+ RETURN_IF_ERROR(codegen_nameop(c, loc, e->v.Name.id, Load));
break;
default:
PyErr_Format(PyExc_SystemError,
@@ -6256,7 +6262,7 @@ codegen_augassign(struct compiler *c, stmt_ty s)
}
break;
case Name_kind:
- return compiler_nameop(c, loc, e->v.Name.id, Store);
+ return codegen_nameop(c, loc, e->v.Name.id, Store);
default:
Py_UNREACHABLE();
}
@@ -7297,7 +7303,7 @@ codegen_match_inner(struct compiler *c, stmt_ty s,
pattern_context *pc)
Py_ssize_t nstores = PyList_GET_SIZE(pc->stores);
for (Py_ssize_t n = 0; n < nstores; n++) {
PyObject *name = PyList_GET_ITEM(pc->stores, n);
- if (compiler_nameop(c, LOC(m->pattern), name, Store) < 0) {
+ if (codegen_nameop(c, LOC(m->pattern), name, Store) < 0) {
Py_DECREF(pc->stores);
return ERROR;
}
@@ -7440,6 +7446,12 @@ compiler_scope_type(struct compiler *c)
return c->u->u_scope_type;
}
+static int
+compiler_is_in_inlined_comp(struct compiler *c)
+{
+ return c->u->u_in_inlined_comp;
+}
+
static PyObject *
compiler_qualname(struct compiler *c)
{
_______________________________________________
Python-checkins mailing list -- python-checkins@python.org
To unsubscribe send an email to python-checkins-le...@python.org
https://mail.python.org/mailman3/lists/python-checkins.python.org/
Member address: arch...@mail-archive.com
