ast_opt.c

/* AST Optimizer */
#include"Python.h"
#include"pycore_ast.h"// _PyAST_GetDocString()
#include"pycore_format.h"// F_LJUST
#include"pycore_long.h"// _PyLong
#include"pycore_pystate.h"// _PyThreadState_GET()
#include"pycore_setobject.h"// _PySet_NextEntry()


typedefstruct {
intoptimize;
intff_features;

intrecursion_depth; /* current recursion depth */
intrecursion_limit; /* recursion limit */
} _PyASTOptimizeState;


staticint
make_const(expr_tynode, PyObject*val, PyArena*arena)
{
// Even if no new value was calculated, make_const may still
// need to clear an error (e.g. for division by zero)
if (val==NULL) {
if (PyErr_ExceptionMatches(PyExc_KeyboardInterrupt)) {
return0;
 }
PyErr_Clear();
return1;
 }
if (_PyArena_AddPyObject(arena, val) <0) {
Py_DECREF(val);
return0;
 }
node->kind=Constant_kind;
node->v.Constant.kind=NULL;
node->v.Constant.value=val;
return1;
}

#defineCOPY_NODE(TO, FROM) (memcpy((TO), (FROM), sizeof(struct _expr)))

staticint
has_starred(asdl_expr_seq*elts)
{
Py_ssize_tn=asdl_seq_LEN(elts);
for (Py_ssize_ti=0; i<n; i++) {
expr_tye= (expr_ty)asdl_seq_GET(elts, i);
if (e->kind==Starred_kind) {
return1;
 }
 }
return0;
}


staticPyObject*
unary_not(PyObject*v)
{
intr=PyObject_IsTrue(v);
if (r<0)
returnNULL;
returnPyBool_FromLong(!r);
}

staticint
fold_unaryop(expr_tynode, PyArena*arena, _PyASTOptimizeState*state)
{
expr_tyarg=node->v.UnaryOp.operand;

if (arg->kind!=Constant_kind) {
/* Fold not into comparison */
if (node->v.UnaryOp.op==Not&&arg->kind==Compare_kind&&
asdl_seq_LEN(arg->v.Compare.ops) ==1) {
/* Eq and NotEq are often implemented in terms of one another, so
 folding not (self == other) into self != other breaks implementation
 of !=. Detecting such cases doesn't seem worthwhile.
 Python uses </> for 'is subset'/'is superset' operations on sets.
 They don't satisfy not folding laws. */
cmpop_tyop=asdl_seq_GET(arg->v.Compare.ops, 0);
switch (op) {
caseIs:
op=IsNot;
break;
caseIsNot:
op=Is;
break;
caseIn:
op=NotIn;
break;
caseNotIn:
op=In;
break;
// The remaining comparison operators can't be safely inverted
caseEq:
caseNotEq:
caseLt:
caseLtE:
caseGt:
caseGtE:
op=0; // The AST enums leave "0" free as an "unused" marker
break;
// No default case, so the compiler will emit a warning if new
// comparison operators are added without being handled here
 }
if (op) {
asdl_seq_SET(arg->v.Compare.ops, 0, op);
COPY_NODE(node, arg);
return1;
 }
 }
return1;
 }

typedefPyObject*(*unary_op)(PyObject*);
staticconstunary_opops[] = {
 [Invert] =PyNumber_Invert,
 [Not] =unary_not,
 [UAdd] =PyNumber_Positive,
 [USub] =PyNumber_Negative,
 };
PyObject*newval=ops[node->v.UnaryOp.op](arg->v.Constant.value);
returnmake_const(node, newval, arena);
}

/* Check whether a collection doesn't containing too much items (including
 subcollections). This protects from creating a constant that needs
 too much time for calculating a hash.
 "limit" is the maximal number of items.
 Returns the negative number if the total number of items exceeds the
 limit. Otherwise returns the limit minus the total number of items.
*/

staticPy_ssize_t
check_complexity(PyObject*obj, Py_ssize_tlimit)
{
if (PyTuple_Check(obj)) {
Py_ssize_ti;
limit-=PyTuple_GET_SIZE(obj);
for (i=0; limit >= 0&&i<PyTuple_GET_SIZE(obj); i++) {
limit=check_complexity(PyTuple_GET_ITEM(obj, i), limit);
 }
returnlimit;
 }
returnlimit;
}

#defineMAX_INT_SIZE 128 /* bits */
#defineMAX_COLLECTION_SIZE 256 /* items */
#defineMAX_STR_SIZE 4096 /* characters */
#defineMAX_TOTAL_ITEMS 1024 /* including nested collections */

staticPyObject*
safe_multiply(PyObject*v, PyObject*w)
{
if (PyLong_Check(v) &&PyLong_Check(w) &&
 !_PyLong_IsZero((PyLongObject*)v) && !_PyLong_IsZero((PyLongObject*)w)
 ) {
size_tvbits=_PyLong_NumBits(v);
size_twbits=_PyLong_NumBits(w);
if (vbits== (size_t)-1||wbits== (size_t)-1) {
returnNULL;
 }
if (vbits+wbits>MAX_INT_SIZE) {
returnNULL;
 }
 }
elseif (PyLong_Check(v) &&PyTuple_Check(w)) {
Py_ssize_tsize=PyTuple_GET_SIZE(w);
if (size) {
longn=PyLong_AsLong(v);
if (n<0||n>MAX_COLLECTION_SIZE / size) {
returnNULL;
 }
if (n&&check_complexity(w, MAX_TOTAL_ITEMS / n) <0) {
returnNULL;
 }
 }
 }
elseif (PyLong_Check(v) && (PyUnicode_Check(w) ||PyBytes_Check(w))) {
Py_ssize_tsize=PyUnicode_Check(w) ? PyUnicode_GET_LENGTH(w) :
PyBytes_GET_SIZE(w);
if (size) {
longn=PyLong_AsLong(v);
if (n<0||n>MAX_STR_SIZE / size) {
returnNULL;
 }
 }
 }
elseif (PyLong_Check(w) &&
 (PyTuple_Check(v) ||PyUnicode_Check(v) ||PyBytes_Check(v)))
 {
returnsafe_multiply(w, v);
 }

returnPyNumber_Multiply(v, w);
}

staticPyObject*
safe_power(PyObject*v, PyObject*w)
{
if (PyLong_Check(v) &&PyLong_Check(w) &&
 !_PyLong_IsZero((PyLongObject*)v) &&_PyLong_IsPositive((PyLongObject*)w)
 ) {
size_tvbits=_PyLong_NumBits(v);
size_twbits=PyLong_AsSize_t(w);
if (vbits== (size_t)-1||wbits== (size_t)-1) {
returnNULL;
 }
if (vbits>MAX_INT_SIZE / wbits) {
returnNULL;
 }
 }

returnPyNumber_Power(v, w, Py_None);
}

staticPyObject*
safe_lshift(PyObject*v, PyObject*w)
{
if (PyLong_Check(v) &&PyLong_Check(w) &&
 !_PyLong_IsZero((PyLongObject*)v) && !_PyLong_IsZero((PyLongObject*)w)
 ) {
size_tvbits=_PyLong_NumBits(v);
size_twbits=PyLong_AsSize_t(w);
if (vbits== (size_t)-1||wbits== (size_t)-1) {
returnNULL;
 }
if (wbits>MAX_INT_SIZE||vbits>MAX_INT_SIZE-wbits) {
returnNULL;
 }
 }

returnPyNumber_Lshift(v, w);
}

staticPyObject*
safe_mod(PyObject*v, PyObject*w)
{
if (PyUnicode_Check(v) ||PyBytes_Check(v)) {
returnNULL;
 }

returnPyNumber_Remainder(v, w);
}


staticexpr_ty
parse_literal(PyObject*fmt, Py_ssize_t*ppos, PyArena*arena)
{
constvoid*data=PyUnicode_DATA(fmt);
intkind=PyUnicode_KIND(fmt);
Py_ssize_tsize=PyUnicode_GET_LENGTH(fmt);
Py_ssize_tstart, pos;
inthas_percents=0;
start=pos=*ppos;
while (pos<size) {
if (PyUnicode_READ(kind, data, pos) !='%') {
pos++;
 }
elseif (pos+1<size&&PyUnicode_READ(kind, data, pos+1) =='%') {
has_percents=1;
pos+=2;
 }
else {
break;
 }
 }
*ppos=pos;
if (pos==start) {
returnNULL;
 }
PyObject*str=PyUnicode_Substring(fmt, start, pos);
/* str = str.replace('%%', '%') */
if (str&&has_percents) {
_Py_DECLARE_STR(dbl_percent, "%%");
Py_SETREF(str, PyUnicode_Replace(str, &_Py_STR(dbl_percent),
_Py_LATIN1_CHR('%'), -1));
 }
if (!str) {
returnNULL;
 }

if (_PyArena_AddPyObject(arena, str) <0) {
Py_DECREF(str);
returnNULL;
 }
return_PyAST_Constant(str, NULL, -1, -1, -1, -1, arena);
}

#defineMAXDIGITS 3

staticint
simple_format_arg_parse(PyObject*fmt, Py_ssize_t*ppos,
int*spec, int*flags, int*width, int*prec)
{
Py_ssize_tpos=*ppos, len=PyUnicode_GET_LENGTH(fmt);
Py_UCS4ch;

#defineNEXTC do { \
 if (pos >= len) { \
 return 0; \
 } \
 ch = PyUnicode_READ_CHAR(fmt, pos); \
 pos++; \
} while (0)

*flags=0;
while (1) {
NEXTC;
switch (ch) {
case'-': *flags |= F_LJUST; continue;
case'+': *flags |= F_SIGN; continue;
case' ': *flags |= F_BLANK; continue;
case'#': *flags |= F_ALT; continue;
case'0': *flags |= F_ZERO; continue;
 }
break;
 }
if ('0' <= ch&&ch <= '9') {
*width=0;
intdigits=0;
while ('0' <= ch&&ch <= '9') {
*width=*width*10+ (ch-'0');
NEXTC;
if (++digits >= MAXDIGITS) {
return0;
 }
 }
 }

if (ch=='.') {
NEXTC;
*prec=0;
if ('0' <= ch&&ch <= '9') {
intdigits=0;
while ('0' <= ch&&ch <= '9') {
*prec=*prec*10+ (ch-'0');
NEXTC;
if (++digits >= MAXDIGITS) {
return0;
 }
 }
 }
 }
*spec=ch;
*ppos=pos;
return1;

#undef NEXTC
}

staticexpr_ty
parse_format(PyObject*fmt, Py_ssize_t*ppos, expr_tyarg, PyArena*arena)
{
intspec, flags, width=-1, prec=-1;
if (!simple_format_arg_parse(fmt, ppos, &spec, &flags, &width, &prec)) {
// Unsupported format.
returnNULL;
 }
if (spec=='s'||spec=='r'||spec=='a') {
charbuf[1+MAXDIGITS+1+MAXDIGITS+1], *p=buf;
if (!(flags&F_LJUST) &&width>0) {
*p++='>';
 }
if (width >= 0) {
p+=snprintf(p, MAXDIGITS+1, "%d", width);
 }
if (prec >= 0) {
p+=snprintf(p, MAXDIGITS+2, ".%d", prec);
 }
expr_tyformat_spec=NULL;
if (p!=buf) {
PyObject*str=PyUnicode_FromString(buf);
if (str==NULL) {
returnNULL;
 }
if (_PyArena_AddPyObject(arena, str) <0) {
Py_DECREF(str);
returnNULL;
 }
format_spec=_PyAST_Constant(str, NULL, -1, -1, -1, -1, arena);
if (format_spec==NULL) {
returnNULL;
 }
 }
return_PyAST_FormattedValue(arg, spec, format_spec,
arg->lineno, arg->col_offset,
arg->end_lineno, arg->end_col_offset,
arena);
 }
// Unsupported format.
returnNULL;
}

staticint
optimize_format(expr_tynode, PyObject*fmt, asdl_expr_seq*elts, PyArena*arena)
{
Py_ssize_tpos=0;
Py_ssize_tcnt=0;
asdl_expr_seq*seq=_Py_asdl_expr_seq_new(asdl_seq_LEN(elts) *2+1, arena);
if (!seq) {
return0;
 }
seq->size=0;

while (1) {
expr_tylit=parse_literal(fmt, &pos, arena);
if (lit) {
asdl_seq_SET(seq, seq->size++, lit);
 }
elseif (PyErr_Occurred()) {
return0;
 }

if (pos >= PyUnicode_GET_LENGTH(fmt)) {
break;
 }
if (cnt >= asdl_seq_LEN(elts)) {
// More format units than items.
return1;
 }
assert(PyUnicode_READ_CHAR(fmt, pos) =='%');
pos++;
expr_tyexpr=parse_format(fmt, &pos, asdl_seq_GET(elts, cnt), arena);
cnt++;
if (!expr) {
return !PyErr_Occurred();
 }
asdl_seq_SET(seq, seq->size++, expr);
 }
if (cnt<asdl_seq_LEN(elts)) {
// More items than format units.
return1;
 }
expr_tyres=_PyAST_JoinedStr(seq,
node->lineno, node->col_offset,
node->end_lineno, node->end_col_offset,
arena);
if (!res) {
return0;
 }
COPY_NODE(node, res);
// PySys_FormatStderr("format = %R\n", fmt);
return1;
}

staticint
fold_binop(expr_tynode, PyArena*arena, _PyASTOptimizeState*state)
{
expr_tylhs, rhs;
lhs=node->v.BinOp.left;
rhs=node->v.BinOp.right;
if (lhs->kind!=Constant_kind) {
return1;
 }
PyObject*lv=lhs->v.Constant.value;

if (node->v.BinOp.op==Mod&&
rhs->kind==Tuple_kind&&
PyUnicode_Check(lv) &&
 !has_starred(rhs->v.Tuple.elts))
 {
returnoptimize_format(node, lv, rhs->v.Tuple.elts, arena);
 }

if (rhs->kind!=Constant_kind) {
return1;
 }

PyObject*rv=rhs->v.Constant.value;
PyObject*newval=NULL;

switch (node->v.BinOp.op) {
caseAdd:
newval=PyNumber_Add(lv, rv);
break;
caseSub:
newval=PyNumber_Subtract(lv, rv);
break;
caseMult:
newval=safe_multiply(lv, rv);
break;
caseDiv:
newval=PyNumber_TrueDivide(lv, rv);
break;
caseFloorDiv:
newval=PyNumber_FloorDivide(lv, rv);
break;
caseMod:
newval=safe_mod(lv, rv);
break;
casePow:
newval=safe_power(lv, rv);
break;
caseLShift:
newval=safe_lshift(lv, rv);
break;
caseRShift:
newval=PyNumber_Rshift(lv, rv);
break;
caseBitOr:
newval=PyNumber_Or(lv, rv);
break;
caseBitXor:
newval=PyNumber_Xor(lv, rv);
break;
caseBitAnd:
newval=PyNumber_And(lv, rv);
break;
// No builtin constants implement the following operators
caseMatMult:
return1;
// No default case, so the compiler will emit a warning if new binary
// operators are added without being handled here
 }

returnmake_const(node, newval, arena);
}

staticPyObject*
make_const_tuple(asdl_expr_seq*elts)
{
for (inti=0; i<asdl_seq_LEN(elts); i++) {
expr_tye= (expr_ty)asdl_seq_GET(elts, i);
if (e->kind!=Constant_kind) {
returnNULL;
 }
 }

PyObject*newval=PyTuple_New(asdl_seq_LEN(elts));
if (newval==NULL) {
returnNULL;
 }

for (inti=0; i<asdl_seq_LEN(elts); i++) {
expr_tye= (expr_ty)asdl_seq_GET(elts, i);
PyObject*v=e->v.Constant.value;
PyTuple_SET_ITEM(newval, i, Py_NewRef(v));
 }
returnnewval;
}

staticint
fold_tuple(expr_tynode, PyArena*arena, _PyASTOptimizeState*state)
{
PyObject*newval;

if (node->v.Tuple.ctx!=Load)
return1;

newval=make_const_tuple(node->v.Tuple.elts);
returnmake_const(node, newval, arena);
}

staticint
fold_subscr(expr_tynode, PyArena*arena, _PyASTOptimizeState*state)
{
PyObject*newval;
expr_tyarg, idx;

arg=node->v.Subscript.value;
idx=node->v.Subscript.slice;
if (node->v.Subscript.ctx!=Load||
arg->kind!=Constant_kind||
idx->kind!=Constant_kind)
 {
return1;
 }

newval=PyObject_GetItem(arg->v.Constant.value, idx->v.Constant.value);
returnmake_const(node, newval, arena);
}

/* Change literal list or set of constants into constant
 tuple or frozenset respectively. Change literal list of
 non-constants into tuple.
 Used for right operand of "in" and "not in" tests and for iterable
 in "for" loop and comprehensions.
*/
staticint
fold_iter(expr_tyarg, PyArena*arena, _PyASTOptimizeState*state)
{
PyObject*newval;
if (arg->kind==List_kind) {
/* First change a list into tuple. */
asdl_expr_seq*elts=arg->v.List.elts;
if (has_starred(elts)) {
return1;
 }
expr_context_tyctx=arg->v.List.ctx;
arg->kind=Tuple_kind;
arg->v.Tuple.elts=elts;
arg->v.Tuple.ctx=ctx;
/* Try to create a constant tuple. */
newval=make_const_tuple(elts);
 }
elseif (arg->kind==Set_kind) {
newval=make_const_tuple(arg->v.Set.elts);
if (newval) {
Py_SETREF(newval, PyFrozenSet_New(newval));
 }
 }
else {
return1;
 }
returnmake_const(arg, newval, arena);
}

staticint
fold_compare(expr_tynode, PyArena*arena, _PyASTOptimizeState*state)
{
asdl_int_seq*ops;
asdl_expr_seq*args;
Py_ssize_ti;

ops=node->v.Compare.ops;
args=node->v.Compare.comparators;
/* Change literal list or set in 'in' or 'not in' into
 tuple or frozenset respectively. */
i=asdl_seq_LEN(ops) -1;
intop=asdl_seq_GET(ops, i);
if (op==In||op==NotIn) {
if (!fold_iter((expr_ty)asdl_seq_GET(args, i), arena, state)) {
return0;
 }
 }
return1;
}

staticintastfold_mod(mod_tynode_, PyArena*ctx_, _PyASTOptimizeState*state);
staticintastfold_stmt(stmt_tynode_, PyArena*ctx_, _PyASTOptimizeState*state);
staticintastfold_expr(expr_tynode_, PyArena*ctx_, _PyASTOptimizeState*state);
staticintastfold_arguments(arguments_tynode_, PyArena*ctx_, _PyASTOptimizeState*state);
staticintastfold_comprehension(comprehension_tynode_, PyArena*ctx_, _PyASTOptimizeState*state);
staticintastfold_keyword(keyword_tynode_, PyArena*ctx_, _PyASTOptimizeState*state);
staticintastfold_arg(arg_tynode_, PyArena*ctx_, _PyASTOptimizeState*state);
staticintastfold_withitem(withitem_tynode_, PyArena*ctx_, _PyASTOptimizeState*state);
staticintastfold_excepthandler(excepthandler_tynode_, PyArena*ctx_, _PyASTOptimizeState*state);
staticintastfold_match_case(match_case_tynode_, PyArena*ctx_, _PyASTOptimizeState*state);
staticintastfold_pattern(pattern_tynode_, PyArena*ctx_, _PyASTOptimizeState*state);
staticintastfold_type_param(type_param_tynode_, PyArena*ctx_, _PyASTOptimizeState*state);

#defineCALL(FUNC, TYPE, ARG) \
 if (!FUNC((ARG), ctx_, state)) \
 return 0;

#defineCALL_OPT(FUNC, TYPE, ARG) \
 if ((ARG) != NULL && !FUNC((ARG), ctx_, state)) \
 return 0;

#defineCALL_SEQ(FUNC, TYPE, ARG) { \
 int i; \
 asdl_ ## TYPE ## _seq *seq = (ARG); /* avoid variable capture */ \
for (i = 0; i < asdl_seq_LEN(seq); i++) { \
 TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
 if (elt != NULL && !FUNC(elt, ctx_, state)) \
 return 0; \
 } \
}


staticint
astfold_body(asdl_stmt_seq*stmts, PyArena*ctx_, _PyASTOptimizeState*state)
{
intdocstring=_PyAST_GetDocString(stmts) !=NULL;
CALL_SEQ(astfold_stmt, stmt, stmts);
if (!docstring&&_PyAST_GetDocString(stmts) !=NULL) {
stmt_tyst= (stmt_ty)asdl_seq_GET(stmts, 0);
asdl_expr_seq*values=_Py_asdl_expr_seq_new(1, ctx_);
if (!values) {
return0;
 }
asdl_seq_SET(values, 0, st->v.Expr.value);
expr_tyexpr=_PyAST_JoinedStr(values, st->lineno, st->col_offset,
st->end_lineno, st->end_col_offset,
ctx_);
if (!expr) {
return0;
 }
st->v.Expr.value=expr;
 }
return1;
}

staticint
astfold_mod(mod_tynode_, PyArena*ctx_, _PyASTOptimizeState*state)
{
switch (node_->kind) {
caseModule_kind:
CALL(astfold_body, asdl_seq, node_->v.Module.body);
break;
caseInteractive_kind:
CALL_SEQ(astfold_stmt, stmt, node_->v.Interactive.body);
break;
caseExpression_kind:
CALL(astfold_expr, expr_ty, node_->v.Expression.body);
break;
// The following top level nodes don't participate in constant folding
caseFunctionType_kind:
break;
// No default case, so the compiler will emit a warning if new top level
// compilation nodes are added without being handled here
 }
return1;
}

staticint
astfold_expr(expr_tynode_, PyArena*ctx_, _PyASTOptimizeState*state)
{
if (++state->recursion_depth>state->recursion_limit) {
PyErr_SetString(PyExc_RecursionError,
"maximum recursion depth exceeded during compilation");
return0;
 }
switch (node_->kind) {
caseBoolOp_kind:
CALL_SEQ(astfold_expr, expr, node_->v.BoolOp.values);
break;
caseBinOp_kind:
CALL(astfold_expr, expr_ty, node_->v.BinOp.left);
CALL(astfold_expr, expr_ty, node_->v.BinOp.right);
CALL(fold_binop, expr_ty, node_);
break;
caseUnaryOp_kind:
CALL(astfold_expr, expr_ty, node_->v.UnaryOp.operand);
CALL(fold_unaryop, expr_ty, node_);
break;
caseLambda_kind:
CALL(astfold_arguments, arguments_ty, node_->v.Lambda.args);
CALL(astfold_expr, expr_ty, node_->v.Lambda.body);
break;
caseIfExp_kind:
CALL(astfold_expr, expr_ty, node_->v.IfExp.test);
CALL(astfold_expr, expr_ty, node_->v.IfExp.body);
CALL(astfold_expr, expr_ty, node_->v.IfExp.orelse);
break;
caseDict_kind:
CALL_SEQ(astfold_expr, expr, node_->v.Dict.keys);
CALL_SEQ(astfold_expr, expr, node_->v.Dict.values);
break;
caseSet_kind:
CALL_SEQ(astfold_expr, expr, node_->v.Set.elts);
break;
caseListComp_kind:
CALL(astfold_expr, expr_ty, node_->v.ListComp.elt);
CALL_SEQ(astfold_comprehension, comprehension, node_->v.ListComp.generators);
break;
caseSetComp_kind:
CALL(astfold_expr, expr_ty, node_->v.SetComp.elt);
CALL_SEQ(astfold_comprehension, comprehension, node_->v.SetComp.generators);
break;
caseDictComp_kind:
CALL(astfold_expr, expr_ty, node_->v.DictComp.key);
CALL(astfold_expr, expr_ty, node_->v.DictComp.value);
CALL_SEQ(astfold_comprehension, comprehension, node_->v.DictComp.generators);
break;
caseGeneratorExp_kind:
CALL(astfold_expr, expr_ty, node_->v.GeneratorExp.elt);
CALL_SEQ(astfold_comprehension, comprehension, node_->v.GeneratorExp.generators);
break;
caseAwait_kind:
CALL(astfold_expr, expr_ty, node_->v.Await.value);
break;
caseYield_kind:
CALL_OPT(astfold_expr, expr_ty, node_->v.Yield.value);
break;
caseYieldFrom_kind:
CALL(astfold_expr, expr_ty, node_->v.YieldFrom.value);
break;
caseCompare_kind:
CALL(astfold_expr, expr_ty, node_->v.Compare.left);
CALL_SEQ(astfold_expr, expr, node_->v.Compare.comparators);
CALL(fold_compare, expr_ty, node_);
break;
caseCall_kind:
CALL(astfold_expr, expr_ty, node_->v.Call.func);
CALL_SEQ(astfold_expr, expr, node_->v.Call.args);
CALL_SEQ(astfold_keyword, keyword, node_->v.Call.keywords);
break;
caseFormattedValue_kind:
CALL(astfold_expr, expr_ty, node_->v.FormattedValue.value);
CALL_OPT(astfold_expr, expr_ty, node_->v.FormattedValue.format_spec);
break;
caseJoinedStr_kind:
CALL_SEQ(astfold_expr, expr, node_->v.JoinedStr.values);
break;
caseAttribute_kind:
CALL(astfold_expr, expr_ty, node_->v.Attribute.value);
break;
caseSubscript_kind:
CALL(astfold_expr, expr_ty, node_->v.Subscript.value);
CALL(astfold_expr, expr_ty, node_->v.Subscript.slice);
CALL(fold_subscr, expr_ty, node_);
break;
caseStarred_kind:
CALL(astfold_expr, expr_ty, node_->v.Starred.value);
break;
caseSlice_kind:
CALL_OPT(astfold_expr, expr_ty, node_->v.Slice.lower);
CALL_OPT(astfold_expr, expr_ty, node_->v.Slice.upper);
CALL_OPT(astfold_expr, expr_ty, node_->v.Slice.step);
break;
caseList_kind:
CALL_SEQ(astfold_expr, expr, node_->v.List.elts);
break;
caseTuple_kind:
CALL_SEQ(astfold_expr, expr, node_->v.Tuple.elts);
CALL(fold_tuple, expr_ty, node_);
break;
caseName_kind:
if (node_->v.Name.ctx==Load&&
_PyUnicode_EqualToASCIIString(node_->v.Name.id, "__debug__")) {
state->recursion_depth--;
returnmake_const(node_, PyBool_FromLong(!state->optimize), ctx_);
 }
break;
caseNamedExpr_kind:
CALL(astfold_expr, expr_ty, node_->v.NamedExpr.value);
break;
caseConstant_kind:
// Already a constant, nothing further to do
break;
// No default case, so the compiler will emit a warning if new expression
// kinds are added without being handled here
 }
state->recursion_depth--;
return1;
}

staticint
astfold_keyword(keyword_tynode_, PyArena*ctx_, _PyASTOptimizeState*state)
{
CALL(astfold_expr, expr_ty, node_->value);
return1;
}

staticint
astfold_comprehension(comprehension_tynode_, PyArena*ctx_, _PyASTOptimizeState*state)
{
CALL(astfold_expr, expr_ty, node_->target);
CALL(astfold_expr, expr_ty, node_->iter);
CALL_SEQ(astfold_expr, expr, node_->ifs);

CALL(fold_iter, expr_ty, node_->iter);
return1;
}

staticint
astfold_arguments(arguments_tynode_, PyArena*ctx_, _PyASTOptimizeState*state)
{
CALL_SEQ(astfold_arg, arg, node_->posonlyargs);
CALL_SEQ(astfold_arg, arg, node_->args);
CALL_OPT(astfold_arg, arg_ty, node_->vararg);
CALL_SEQ(astfold_arg, arg, node_->kwonlyargs);
CALL_SEQ(astfold_expr, expr, node_->kw_defaults);
CALL_OPT(astfold_arg, arg_ty, node_->kwarg);
CALL_SEQ(astfold_expr, expr, node_->defaults);
return1;
}

staticint
astfold_arg(arg_tynode_, PyArena*ctx_, _PyASTOptimizeState*state)
{
if (!(state->ff_features&CO_FUTURE_ANNOTATIONS)) {
CALL_OPT(astfold_expr, expr_ty, node_->annotation);
 }
return1;
}

staticint
astfold_stmt(stmt_tynode_, PyArena*ctx_, _PyASTOptimizeState*state)
{
if (++state->recursion_depth>state->recursion_limit) {
PyErr_SetString(PyExc_RecursionError,
"maximum recursion depth exceeded during compilation");
return0;
 }
switch (node_->kind) {
caseFunctionDef_kind:
CALL_SEQ(astfold_type_param, type_param, node_->v.FunctionDef.type_params);
CALL(astfold_arguments, arguments_ty, node_->v.FunctionDef.args);
CALL(astfold_body, asdl_seq, node_->v.FunctionDef.body);
CALL_SEQ(astfold_expr, expr, node_->v.FunctionDef.decorator_list);
if (!(state->ff_features&CO_FUTURE_ANNOTATIONS)) {
CALL_OPT(astfold_expr, expr_ty, node_->v.FunctionDef.returns);
 }
break;
caseAsyncFunctionDef_kind:
CALL_SEQ(astfold_type_param, type_param, node_->v.AsyncFunctionDef.type_params);
CALL(astfold_arguments, arguments_ty, node_->v.AsyncFunctionDef.args);
CALL(astfold_body, asdl_seq, node_->v.AsyncFunctionDef.body);
CALL_SEQ(astfold_expr, expr, node_->v.AsyncFunctionDef.decorator_list);
if (!(state->ff_features&CO_FUTURE_ANNOTATIONS)) {
CALL_OPT(astfold_expr, expr_ty, node_->v.AsyncFunctionDef.returns);
 }
break;
caseClassDef_kind:
CALL_SEQ(astfold_type_param, type_param, node_->v.ClassDef.type_params);
CALL_SEQ(astfold_expr, expr, node_->v.ClassDef.bases);
CALL_SEQ(astfold_keyword, keyword, node_->v.ClassDef.keywords);
CALL(astfold_body, asdl_seq, node_->v.ClassDef.body);
CALL_SEQ(astfold_expr, expr, node_->v.ClassDef.decorator_list);
break;
caseReturn_kind:
CALL_OPT(astfold_expr, expr_ty, node_->v.Return.value);
break;
caseDelete_kind:
CALL_SEQ(astfold_expr, expr, node_->v.Delete.targets);
break;
caseAssign_kind:
CALL_SEQ(astfold_expr, expr, node_->v.Assign.targets);
CALL(astfold_expr, expr_ty, node_->v.Assign.value);
break;
caseAugAssign_kind:
CALL(astfold_expr, expr_ty, node_->v.AugAssign.target);
CALL(astfold_expr, expr_ty, node_->v.AugAssign.value);
break;
caseAnnAssign_kind:
CALL(astfold_expr, expr_ty, node_->v.AnnAssign.target);
if (!(state->ff_features&CO_FUTURE_ANNOTATIONS)) {
CALL(astfold_expr, expr_ty, node_->v.AnnAssign.annotation);
 }
CALL_OPT(astfold_expr, expr_ty, node_->v.AnnAssign.value);
break;
caseTypeAlias_kind:
CALL(astfold_expr, expr_ty, node_->v.TypeAlias.name);
CALL_SEQ(astfold_type_param, type_param, node_->v.TypeAlias.type_params);
CALL(astfold_expr, expr_ty, node_->v.TypeAlias.value);
break;
caseFor_kind:
CALL(astfold_expr, expr_ty, node_->v.For.target);
CALL(astfold_expr, expr_ty, node_->v.For.iter);
CALL_SEQ(astfold_stmt, stmt, node_->v.For.body);
CALL_SEQ(astfold_stmt, stmt, node_->v.For.orelse);

CALL(fold_iter, expr_ty, node_->v.For.iter);
break;
caseAsyncFor_kind:
CALL(astfold_expr, expr_ty, node_->v.AsyncFor.target);
CALL(astfold_expr, expr_ty, node_->v.AsyncFor.iter);
CALL_SEQ(astfold_stmt, stmt, node_->v.AsyncFor.body);
CALL_SEQ(astfold_stmt, stmt, node_->v.AsyncFor.orelse);
break;
caseWhile_kind:
CALL(astfold_expr, expr_ty, node_->v.While.test);
CALL_SEQ(astfold_stmt, stmt, node_->v.While.body);
CALL_SEQ(astfold_stmt, stmt, node_->v.While.orelse);
break;
caseIf_kind:
CALL(astfold_expr, expr_ty, node_->v.If.test);
CALL_SEQ(astfold_stmt, stmt, node_->v.If.body);
CALL_SEQ(astfold_stmt, stmt, node_->v.If.orelse);
break;
caseWith_kind:
CALL_SEQ(astfold_withitem, withitem, node_->v.With.items);
CALL_SEQ(astfold_stmt, stmt, node_->v.With.body);
break;
caseAsyncWith_kind:
CALL_SEQ(astfold_withitem, withitem, node_->v.AsyncWith.items);
CALL_SEQ(astfold_stmt, stmt, node_->v.AsyncWith.body);
break;
caseRaise_kind:
CALL_OPT(astfold_expr, expr_ty, node_->v.Raise.exc);
CALL_OPT(astfold_expr, expr_ty, node_->v.Raise.cause);
break;
caseTry_kind:
CALL_SEQ(astfold_stmt, stmt, node_->v.Try.body);
CALL_SEQ(astfold_excepthandler, excepthandler, node_->v.Try.handlers);
CALL_SEQ(astfold_stmt, stmt, node_->v.Try.orelse);
CALL_SEQ(astfold_stmt, stmt, node_->v.Try.finalbody);
break;
caseTryStar_kind:
CALL_SEQ(astfold_stmt, stmt, node_->v.TryStar.body);
CALL_SEQ(astfold_excepthandler, excepthandler, node_->v.TryStar.handlers);
CALL_SEQ(astfold_stmt, stmt, node_->v.TryStar.orelse);
CALL_SEQ(astfold_stmt, stmt, node_->v.TryStar.finalbody);
break;
caseAssert_kind:
CALL(astfold_expr, expr_ty, node_->v.Assert.test);
CALL_OPT(astfold_expr, expr_ty, node_->v.Assert.msg);
break;
caseExpr_kind:
CALL(astfold_expr, expr_ty, node_->v.Expr.value);
break;
caseMatch_kind:
CALL(astfold_expr, expr_ty, node_->v.Match.subject);
CALL_SEQ(astfold_match_case, match_case, node_->v.Match.cases);
break;
// The following statements don't contain any subexpressions to be folded
caseImport_kind:
caseImportFrom_kind:
caseGlobal_kind:
caseNonlocal_kind:
casePass_kind:
caseBreak_kind:
caseContinue_kind:
break;
// No default case, so the compiler will emit a warning if new statement
// kinds are added without being handled here