#include "Python.h"

#include "pycore_ast.h"           // expr_ty

#include "pycore_runtime.h"       // _Py_ID()

#include <float.h>                // DBL_MAX_10_EXP

#include <stdbool.h>

/* This limited unparser is used to convert annotations back to strings

 * during compilation rather than being a full AST unparser.

 * See ast.unparse for a full unparser (written in Python)

 */

_Py_DECLARE_STR(open_br, "{");

_Py_DECLARE_STR(dbl_open_br, "{{");

_Py_DECLARE_STR(close_br, "}");

_Py_DECLARE_STR(dbl_close_br, "}}");

static PyObject *_str_replace_inf;

/* Forward declarations for recursion via helper functions. */

static PyObject *

expr_as_unicode(expr_ty e, int level);

static int

append_ast_expr(_PyUnicodeWriter *writer, expr_ty e, int level);

static int

append_joinedstr(_PyUnicodeWriter *writer, expr_ty e, bool is_format_spec);

static int

append_formattedvalue(_PyUnicodeWriter *writer, expr_ty e);

static int

append_ast_slice(_PyUnicodeWriter *writer, expr_ty e);

static int

append_charp(_PyUnicodeWriter *writer, const char *charp)

{

    return _PyUnicodeWriter_WriteASCIIString(writer, charp, -1);

}

#define APPEND_STR_FINISH(str)  do { \

        return append_charp(writer, (str)); \

    } while (
00
)

#define APPEND_STR(str)  do { \

        if (-1 == append_charp(writer, (
str672
))) { \

            return -1; \

        } \

    } while (0)

#define APPEND_STR_IF(cond, str)  do { \

        if ((cond) && 
-1 == append_charp(writer, (str))2.49k
) { \

            return -1; \

        } \

    } while (0)

#define APPEND_STR_IF_NOT_FIRST(str)  do { \

        APPEND_STR_IF(!first, (str)); \

        first = false; \

    } while (0)

#define APPEND_EXPR(expr, pr)  do { \

        if (-1 == append_ast_expr(writer, (expr), (pr))) { \

            return -1; \

        } \

    } while (0)

#define APPEND(type, value)  do { \

        if (-1 == append_ast_ ## type(writer, (value))) { \

            return -1; \

        } \

    } while (0)

static int

append_repr(_PyUnicodeWriter *writer, PyObject *obj)

{

    PyObject *repr = PyObject_Repr(obj);

    if (!repr) {

  Branch (74:9): [True: 0, False: 2.25k]

        return -1;

    }

    if ((PyFloat_CheckExact(obj) && Py_IS_INFINITY(PyFloat_AS_DOUBLE(obj))) ||

       
PyComplex_CheckExact2.22k
(obj))

    {

        PyObject *new_repr = PyUnicode_Replace(

            repr,

            &_Py_ID(inf),

            _str_replace_inf,

            -1

        );

        Py_DECREF(repr);

        if (!new_repr) {

  Branch (88:13): [True: 0, False: 77]

            return -1;

        }

        repr = new_repr;

    }

    int ret = _PyUnicodeWriter_WriteStr(writer, repr);

    Py_DECREF(repr);

    return ret;

}

/* Priority levels */

enum {

    PR_TUPLE,

    PR_TEST,            /* 'if'-'else', 'lambda' */

    PR_OR,              /* 'or' */

    PR_AND,             /* 'and' */

    PR_NOT,             /* 'not' */

    PR_CMP,             /* '<', '>', '==', '>=', '<=', '!=',

                           'in', 'not in', 'is', 'is not' */

    PR_EXPR,

    PR_BOR = PR_EXPR,   /* '|' */

    PR_BXOR,            /* '^' */

    PR_BAND,            /* '&' */

    PR_SHIFT,           /* '<<', '>>' */

    PR_ARITH,           /* '+', '-' */

    PR_TERM,            /* '*', '@', '/', '%', '//' */

    PR_FACTOR,          /* unary '+', '-', '~' */

    PR_POWER,           /* '**' */

    PR_AWAIT,           /* 'await' */

    PR_ATOM,

};

static int

append_ast_boolop(_PyUnicodeWriter *writer, expr_ty e, int level)

{

    Py_ssize_t i, value_count;

    asdl_expr_seq *values;

    const char *op = (e->v.BoolOp.op == And) ? 
" and "70
 : 
" or "154
;

  Branch (126:22): [True: 70, False: 154]

    int pr = (e->v.BoolOp.op == And) ? 
PR_AND70
 : 
PR_OR154
;

  Branch (127:14): [True: 70, False: 154]

    APPEND_STR_IF(level > pr, "(");

    values = e->v.BoolOp.values;

    value_count = asdl_seq_LEN(values);

    for (i = 0; i < value_count; 
++i490
) {

  Branch (134:17): [True: 490, False: 224]

        APPEND_STR_IF(i > 0, op);

        APPEND_EXPR((expr_ty)asdl_seq_GET(values, i), pr + 1);

    }

    APPEND_STR_IF(level > pr, ")");

    return 0;

}

static int

append_ast_binop(_PyUnicodeWriter *writer, expr_ty e, int level)

{

    const char *op;

    int pr;

    bool rassoc = false;  /* is right-associative? */

    switch (e->v.BinOp.op) {

    case Add: op = " + "; pr = PR_ARITH; break;

  Branch (151:5): [True: 252, False: 189]

    case Sub: op = " - "; pr = PR_ARITH; break;

  Branch (152:5): [True: 7, False: 434]

    case Mult: op = " * "; pr = PR_TERM; break;

  Branch (153:5): [True: 28, False: 413]

    case MatMult: op = " @ "; pr = PR_TERM; break;

  Branch (154:5): [True: 0, False: 441]

    case Div: op = " / "; pr = PR_TERM; break;

  Branch (155:5): [True: 7, False: 434]

    case Mod: op = " % "; pr = PR_TERM; break;

  Branch (156:5): [True: 7, False: 434]

    case LShift: op = " << "; pr = PR_SHIFT; break;

  Branch (157:5): [True: 14, False: 427]

    case RShift: op = " >> "; pr = PR_SHIFT; break;

  Branch (158:5): [True: 7, False: 434]

    case BitOr: op = " | "; pr = PR_BOR; break;

  Branch (159:5): [True: 7, False: 434]

    case BitXor: op = " ^ "; pr = PR_BXOR; break;

  Branch (160:5): [True: 14, False: 427]

    case BitAnd: op = " & "; pr = PR_BAND; break;

  Branch (161:5): [True: 0, False: 441]

    case FloorDiv: op = " // "; pr = PR_TERM; break;

  Branch (162:5): [True: 7, False: 434]

    case Pow: op = " ** "; pr = PR_POWER; rassoc = true; break;

  Branch (163:5): [True: 91, False: 350]

    default:

  Branch (164:5): [True: 0, False: 441]

        PyErr_SetString(PyExc_SystemError,

                        "unknown binary operator");

        return -1;

    }

    APPEND_STR_IF(level > pr, "(");

    APPEND_EXPR(e->v.BinOp.left, pr + rassoc);

    APPEND_STR(op);

    APPEND_EXPR(e->v.BinOp.right, pr + !rassoc);

    APPEND_STR_IF(level > pr, ")");

    return 0;

}

static int

append_ast_unaryop(_PyUnicodeWriter *writer, expr_ty e, int level)

{

    const char *op;

    int pr;

    switch (e->v.UnaryOp.op) {

    case Invert: op = "~"; pr = PR_FACTOR; break;

  Branch (185:5): [True: 14, False: 112]

    case Not: op = "not "; pr = PR_NOT; break;

  Branch (186:5): [True: 42, False: 84]

    case UAdd: op = "+"; pr = PR_FACTOR; break;

  Branch (187:5): [True: 28, False: 98]

    case USub: op = "-"; pr = PR_FACTOR; break;

  Branch (188:5): [True: 42, False: 84]

    default:

  Branch (189:5): [True: 0, False: 126]

        PyErr_SetString(PyExc_SystemError,

                        "unknown unary operator");

        return -1;

    }

    APPEND_STR_IF(level > pr, "(");

    APPEND_STR(op);

    APPEND_EXPR(e->v.UnaryOp.operand, pr);

    APPEND_STR_IF(level > pr, ")");

    return 0;

}

static int

append_ast_arg(_PyUnicodeWriter *writer, arg_ty arg)

{

    if (-1 == _PyUnicodeWriter_WriteStr(writer, arg->arg)) {

  Branch (205:9): [True: 0, False: 427]

        return -1;

    }

    if (arg->annotation) {

  Branch (208:9): [True: 0, False: 427]

        APPEND_STR(": ");

        APPEND_EXPR(arg->annotation, PR_TEST);

    }

    return 0;

}

static int

append_ast_args(_PyUnicodeWriter *writer, arguments_ty args)

{

    bool first;

    Py_ssize_t i, di, arg_count, posonlyarg_count, default_count;

    first = true;

    /* positional-only and positional arguments with defaults */

    posonlyarg_count = asdl_seq_LEN(args->posonlyargs);

    arg_count = asdl_seq_LEN(args->args);

    default_count = asdl_seq_LEN(args->defaults);

    for (i = 0; i < posonlyarg_count + arg_count; 
i++294
) {

  Branch (227:17): [True: 294, False: 154]

        APPEND_STR_IF_NOT_FIRST(", ");

        if (i < posonlyarg_count){

  Branch (229:13): [True: 112, False: 182]

            APPEND(arg, (arg_ty)asdl_seq_GET(args->posonlyargs, i));

        } else {

            APPEND(arg, (arg_ty)asdl_seq_GET(args->args, i-posonlyarg_count));

        }

        di = i - posonlyarg_count - arg_count + default_count;

        if (di >= 0) {

  Branch (236:13): [True: 161, False: 133]

            APPEND_STR("=");

            APPEND_EXPR((expr_ty)asdl_seq_GET(args->defaults, di), PR_TEST);

        }

        if (posonlyarg_count && 
i + 1 == posonlyarg_count189
) {

  Branch (240:13): [True: 189, False: 105]
  Branch (240:33): [True: 84, False: 105]

            APPEND_STR(", /");

        }

    }

    /* vararg, or bare '*' if no varargs but keyword-only arguments present */

    if (args->vararg || 
asdl_seq_LEN140
(args->kwonlyargs)) {

  Branch (246:9): [True: 14, False: 140]

        APPEND_STR_IF_NOT_FIRST(", ");

        APPEND_STR("*");

        if (args->vararg) {

  Branch (249:13): [True: 14, False: 49]

            APPEND(arg, args->vararg);

        }

    }

    /* keyword-only arguments */

    arg_count = asdl_seq_LEN(args->kwonlyargs);

    default_count = asdl_seq_LEN(args->kw_defaults);

    for (i = 0; i < arg_count; 
i++98
) {

  Branch (257:17): [True: 98, False: 154]

        APPEND_STR_IF_NOT_FIRST(", ");

        APPEND(arg, (arg_ty)asdl_seq_GET(args->kwonlyargs, i));

        di = i - arg_count + default_count;

        if (di >= 0) {

  Branch (262:13): [True: 98, False: 0]

            expr_ty default_ = (expr_ty)asdl_seq_GET(args->kw_defaults, di);

            if (default_) {

  Branch (264:17): [True: 42, False: 56]

                APPEND_STR("=");

                APPEND_EXPR(default_, PR_TEST);

            }

        }

    }

    /* **kwargs */

    if (args->kwarg) {

  Branch (272:9): [True: 21, False: 133]

        APPEND_STR_IF_NOT_FIRST(", ");

        APPEND_STR("**");

        APPEND(arg, args->kwarg);

    }

    return 0;

}

static int

append_ast_lambda(_PyUnicodeWriter *writer, expr_ty e, int level)

{

    APPEND_STR_IF(level > PR_TEST, "(");

    Py_ssize_t n_positional = (asdl_seq_LEN(e->v.Lambda.args->args) +

                               asdl_seq_LEN(e->v.Lambda.args->posonlyargs));

    APPEND_STR(n_positional ? "lambda " : "lambda");

    APPEND(args, e->v.Lambda.args);

    APPEND_STR(": ");

    APPEND_EXPR(e->v.Lambda.body, PR_TEST);

    APPEND_STR_IF(level > PR_TEST, ")");

    return 0;

}

static int

append_ast_ifexp(_PyUnicodeWriter *writer, expr_ty e, int level)

{

    APPEND_STR_IF(level > PR_TEST, "(");

    APPEND_EXPR(e->v.IfExp.body, PR_TEST + 1);

    APPEND_STR(" if ");

    APPEND_EXPR(e->v.IfExp.test, PR_TEST + 1);

    APPEND_STR(" else ");

    APPEND_EXPR(e->v.IfExp.orelse, PR_TEST);

    APPEND_STR_IF(level > PR_TEST, ")");

    return 0;

}

static int

append_ast_dict(_PyUnicodeWriter *writer, expr_ty e)

{

    Py_ssize_t i, value_count;

    expr_ty key_node;

    APPEND_STR("{");

    value_count = asdl_seq_LEN(e->v.Dict.values);

    for (i = 0; i < value_count; 
i++70
) {

  Branch (317:17): [True: 70, False: 35]

        APPEND_STR_IF(i > 0, ", ");

        key_node = (expr_ty)asdl_seq_GET(e->v.Dict.keys, i);

        if (key_node != NULL) {

  Branch (320:13): [True: 42, False: 28]

            APPEND_EXPR(key_node, PR_TEST);

            APPEND_STR(": ");

            APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.Dict.values, i), PR_TEST);

        }

        else {

            APPEND_STR("**");

            APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.Dict.values, i), PR_EXPR);

        }

    }

    APPEND_STR_FINISH("}");

}

static int

append_ast_set(_PyUnicodeWriter *writer, expr_ty e)

{

    Py_ssize_t i, elem_count;

    APPEND_STR("{");

    elem_count = asdl_seq_LEN(e->v.Set.elts);

    for (i = 0; i < elem_count; 
i++63
) {

  Branch (341:17): [True: 63, False: 14]

        APPEND_STR_IF(i > 0, ", ");

        APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.Set.elts, i), PR_TEST);

    }

    APPEND_STR_FINISH("}");

}

static int

append_ast_list(_PyUnicodeWriter *writer, expr_ty e)

{

    Py_ssize_t i, elem_count;

    APPEND_STR("[");

    elem_count = asdl_seq_LEN(e->v.List.elts);

    for (i = 0; i < elem_count; 
i++105
) {

  Branch (356:17): [True: 105, False: 21]

        APPEND_STR_IF(i > 0, ", ");

        APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.List.elts, i), PR_TEST);

    }

    APPEND_STR_FINISH("]");

}

static int

append_ast_tuple(_PyUnicodeWriter *writer, expr_ty e, int level)

{

    Py_ssize_t i, elem_count;

    elem_count = asdl_seq_LEN(e->v.Tuple.elts);

    if (elem_count == 0) {

  Branch (371:9): [True: 21, False: 553]

        APPEND_STR_FINISH("()");

    }

    APPEND_STR_IF(level > PR_TUPLE, "(");

    
for (i = 0; 553
i < elem_count; 
i++1.30k
) {

  Branch (377:17): [True: 1.30k, False: 553]

        APPEND_STR_IF(i > 0, ", ");

        APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.Tuple.elts, i), PR_TEST);

    }

    APPEND_STR_IF(elem_count == 1, ",");

    APPEND_STR_IF(level > PR_TUPLE, ")");

    return 0;

}

static int

append_ast_comprehension(_PyUnicodeWriter *writer, comprehension_ty gen)

{

    Py_ssize_t i, if_count;

    APPEND_STR(gen->is_async ? " async for " : " for ");

    APPEND_EXPR(gen->target, PR_TUPLE);

    APPEND_STR(" in ");

    APPEND_EXPR(gen->iter, PR_TEST + 1);

    if_count = asdl_seq_LEN(gen->ifs);

    for (i = 0; i < if_count; 
i++7
) {

  Branch (398:17): [True: 7, False: 182]

        APPEND_STR(" if ");

        APPEND_EXPR((expr_ty)asdl_seq_GET(gen->ifs, i), PR_TEST + 1);

    }

    return 0;

}

static int

append_ast_comprehensions(_PyUnicodeWriter *writer, asdl_comprehension_seq *comprehensions)

{

    Py_ssize_t i, gen_count;

    gen_count = asdl_seq_LEN(comprehensions);

    for (i = 0; i < gen_count; 
i++182
) {

  Branch (411:17): [True: 182, False: 161]

        APPEND(comprehension, (comprehension_ty)asdl_seq_GET(comprehensions, i));

    }

    return 0;

}

static int

append_ast_genexp(_PyUnicodeWriter *writer, expr_ty e)

{

    APPEND_STR("(");

    APPEND_EXPR(e->v.GeneratorExp.elt, PR_TEST);

    APPEND(comprehensions, e->v.GeneratorExp.generators);

    APPEND_STR_FINISH(")");

}

static int

append_ast_listcomp(_PyUnicodeWriter *writer, expr_ty e)

{

    APPEND_STR("[");

    APPEND_EXPR(e->v.ListComp.elt, PR_TEST);

    APPEND(comprehensions, e->v.ListComp.generators);

    APPEND_STR_FINISH("]");

}

static int

append_ast_setcomp(_PyUnicodeWriter *writer, expr_ty e)

{

    APPEND_STR("{");

    APPEND_EXPR(e->v.SetComp.elt, PR_TEST);

    APPEND(comprehensions, e->v.SetComp.generators);

    APPEND_STR_FINISH("}");

}

static int

append_ast_dictcomp(_PyUnicodeWriter *writer, expr_ty e)

{

    APPEND_STR("{");

    APPEND_EXPR(e->v.DictComp.key, PR_TEST);

    APPEND_STR(": ");

    APPEND_EXPR(e->v.DictComp.value, PR_TEST);

    APPEND(comprehensions, e->v.DictComp.generators);

    APPEND_STR_FINISH("}");

}

static int

append_ast_compare(_PyUnicodeWriter *writer, expr_ty e, int level)

{

    const char *op;

    Py_ssize_t i, comparator_count;

    asdl_expr_seq *comparators;

    asdl_int_seq *ops;

    APPEND_STR_IF(level > PR_CMP, "(");

    comparators = e->v.Compare.comparators;

    ops = e->v.Compare.ops;

    comparator_count = asdl_seq_LEN(comparators);

    assert(comparator_count > 0);

    assert(comparator_count == asdl_seq_LEN(ops));

    APPEND_EXPR(e->v.Compare.left, PR_CMP + 1);

    
for (i = 0; 35
i < comparator_count; 
i++42
) {

  Branch (474:17): [True: 42, False: 35]

        switch ((cmpop_ty)asdl_seq_GET(ops, i)) {

        case Eq:

  Branch (476:9): [True: 0, False: 42]

            op = " == ";

            break;

        case NotEq:

  Branch (479:9): [True: 0, False: 42]

            op = " != ";

            break;

        case Lt:

  Branch (482:9): [True: 0, False: 42]

            op = " < ";

            break;

        case LtE:

  Branch (485:9): [True: 0, False: 42]

            op = " <= ";

            break;

        case Gt:

  Branch (488:9): [True: 35, False: 7]

            op = " > ";

            break;

        case GtE:

  Branch (491:9): [True: 0, False: 42]

            op = " >= ";

            break;

        case Is:

  Branch (494:9): [True: 7, False: 35]

            op = " is ";

            break;

        case IsNot:

  Branch (497:9): [True: 0, False: 42]

            op = " is not ";

            break;

        case In:

  Branch (500:9): [True: 0, False: 42]

            op = " in ";

            break;

        case NotIn:

  Branch (503:9): [True: 0, False: 42]

            op = " not in ";

            break;

        default:

  Branch (506:9): [True: 0, False: 42]

            PyErr_SetString(PyExc_SystemError,

                            "unexpected comparison kind");

            return -1;

        }

        APPEND_STR(op);

        APPEND_EXPR((expr_ty)asdl_seq_GET(comparators, i), PR_CMP + 1);

    }

    APPEND_STR_IF(level > PR_CMP, ")");

    return 0;

}

static int

append_ast_keyword(_PyUnicodeWriter *writer, keyword_ty kw)

{

    if (kw->arg == NULL) {

  Branch (523:9): [True: 7, False: 35]

        APPEND_STR("**");

    }

    else {

        if (-1 == _PyUnicodeWriter_WriteStr(writer, kw->arg)) {

  Branch (527:13): [True: 0, False: 35]

            return -1;

        }

        APPEND_STR("=");

    }

    APPEND_EXPR(kw->value, PR_TEST);

    return 0;

}

static int

append_ast_call(_PyUnicodeWriter *writer, expr_ty e)

{

    bool first;

    Py_ssize_t i, arg_count, kw_count;

    expr_ty expr;

    APPEND_EXPR(e->v.Call.func, PR_ATOM);

    arg_count = asdl_seq_LEN(e->v.Call.args);

    kw_count = asdl_seq_LEN(e->v.Call.keywords);

    if (arg_count == 1 && 
kw_count == 028
) {

  Branch (549:9): [True: 28, False: 49]
  Branch (549:27): [True: 21, False: 7]

        expr = (expr_ty)asdl_seq_GET(e->v.Call.args, 0);

        if (expr->kind == GeneratorExp_kind) {

  Branch (551:13): [True: 7, False: 14]

            /* Special case: a single generator expression. */

            return append_ast_genexp(writer, expr);

        }

    }

    APPEND_STR("(");

    first = true;

    for (i = 0; i < arg_count; 
i++84
) {

  Branch (560:17): [True: 84, False: 70]

        APPEND_STR_IF_NOT_FIRST(", ");

        APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.Call.args, i), PR_TEST);

    }

    
for (i = 0; 70
i < kw_count; 
i++42
) {

  Branch (565:17): [True: 42, False: 70]

        APPEND_STR_IF_NOT_FIRST(", ");

        APPEND(keyword, (keyword_ty)asdl_seq_GET(e->v.Call.keywords, i));

    }

    APPEND_STR_FINISH(")");

}

static PyObject *

escape_braces(PyObject *orig)

{

    PyObject *temp;

    PyObject *result;

    temp = PyUnicode_Replace(orig, &_Py_STR(open_br), &_Py_STR(dbl_open_br), -1);

    if (!temp) {

  Branch (579:9): [True: 0, False: 119]

        return NULL;

    }

    result = PyUnicode_Replace(temp, &_Py_STR(close_br), &_Py_STR(dbl_close_br), -1);

    Py_DECREF(temp);

    return result;

}

static int

append_fstring_unicode(_PyUnicodeWriter *writer, PyObject *unicode)

{

    PyObject *escaped;

    int result = -1;

    escaped = escape_braces(unicode);

    if (escaped) {

  Branch (593:9): [True: 119, False: 0]

        result = _PyUnicodeWriter_WriteStr(writer, escaped);

        Py_DECREF(escaped);

    }

    return result;

}

static int

append_fstring_element(_PyUnicodeWriter *writer, expr_ty e, bool is_format_spec)

{

    switch (e->kind) {

    case Constant_kind:

  Branch (604:5): [True: 119, False: 147]

        return append_fstring_unicode(writer, e->v.Constant.value);

    case JoinedStr_kind:

  Branch (606:5): [True: 28, False: 238]

        return append_joinedstr(writer, e, is_format_spec);

    case FormattedValue_kind:

  Branch (608:5): [True: 119, False: 147]

        return append_formattedvalue(writer, e);

    default:

  Branch (610:5): [True: 0, False: 266]

        PyErr_SetString(PyExc_SystemError,

                        "unknown expression kind inside f-string");

        return -1;

    }

}

/* Build body separately to enable wrapping the entire stream of Strs,

   Constants and FormattedValues in one opening and one closing quote. */

static PyObject *

build_fstring_body(asdl_expr_seq *values, bool is_format_spec)

{

    Py_ssize_t i, value_count;

    _PyUnicodeWriter body_writer;

    _PyUnicodeWriter_Init(&body_writer);

    body_writer.min_length = 256;

    body_writer.overallocate = 1;

    value_count = asdl_seq_LEN(values);

    for (i = 0; i < value_count; 
++i238
) {

  Branch (629:17): [True: 238, False: 147]

        if (-1 == append_fstring_element(&body_writer,

  Branch (630:13): [True: 0, False: 238]

                                         (expr_ty)asdl_seq_GET(values, i),

                                         is_format_spec

                                         )) {

            _PyUnicodeWriter_Dealloc(&body_writer);

            return NULL;

        }

    }

    return _PyUnicodeWriter_Finish(&body_writer);

}

static int

append_joinedstr(_PyUnicodeWriter *writer, expr_ty e, bool is_format_spec)

{

    int result = -1;

    PyObject *body = build_fstring_body(e->v.JoinedStr.values, is_format_spec);

    if (!body) {

  Branch (647:9): [True: 0, False: 147]

        return -1;

    }

    if (!is_format_spec) {

  Branch (651:9): [True: 119, False: 28]

        if (-1 != append_charp(writer, "f") &&

  Branch (652:13): [True: 119, False: 0]

            -1 != append_repr(writer, body))

  Branch (653:13): [True: 119, False: 0]

        {

            result = 0;

        }

    }

    else {

        result = _PyUnicodeWriter_WriteStr(writer, body);

    }

    Py_DECREF(body);

    return result;

}

static int

append_formattedvalue(_PyUnicodeWriter *writer, expr_ty e)

{

    const char *conversion;

    const char *outer_brace = "{";

    /* Grammar allows PR_TUPLE, but use >PR_TEST for adding parenthesis

       around a lambda with ':' */

    PyObject *temp_fv_str = expr_as_unicode(e->v.FormattedValue.value, PR_TEST + 1);

    if (!temp_fv_str) {

  Branch (673:9): [True: 0, False: 119]

        return -1;

    }

    if (PyUnicode_Find(temp_fv_str, &_Py_STR(open_br), 0, 1, 1) == 0) {

  Branch (676:9): [True: 7, False: 112]

        /* Expression starts with a brace, split it with a space from the outer

           one. */

        outer_brace = "{ ";

    }

    if (-1 == append_charp(writer, outer_brace)) {

  Branch (681:9): [True: 0, False: 119]

        Py_DECREF(temp_fv_str);

        return -1;

    }

    if (-1 == _PyUnicodeWriter_WriteStr(writer, temp_fv_str)) {

  Branch (685:9): [True: 0, False: 119]

        Py_DECREF(temp_fv_str);

        return -1;

    }

    Py_DECREF(temp_fv_str);

    if (e->v.FormattedValue.conversion > 0) {

  Branch (691:9): [True: 49, False: 70]

        switch (e->v.FormattedValue.conversion) {

        case 'a':

  Branch (693:9): [True: 14, False: 35]

            conversion = "!a";

            break;

        case 'r':

  Branch (696:9): [True: 28, False: 21]

            conversion = "!r";

            break;

        case 's':

  Branch (699:9): [True: 7, False: 42]

            conversion = "!s";

            break;

        default:

  Branch (702:9): [True: 0, False: 49]

            PyErr_SetString(PyExc_SystemError,

                            "unknown f-value conversion kind");

            return -1;

        }

        APPEND_STR(conversion);

    }

    if (e->v.FormattedValue.format_spec) {

  Branch (709:9): [True: 28, False: 91]

        if (-1 == _PyUnicodeWriter_WriteASCIIString(writer, ":", 1) ||

  Branch (710:13): [True: 0, False: 28]

            -1 == append_fstring_element(writer,

  Branch (711:13): [True: 0, False: 28]

                                         e->v.FormattedValue.format_spec,

                                         true

                                        ))

        {

            return -1;

        }

    }

    APPEND_STR_FINISH("}");

}

static int

append_ast_constant(_PyUnicodeWriter *writer, PyObject *constant)

{

    if (PyTuple_CheckExact(constant)) {

        Py_ssize_t i, elem_count;

        elem_count = PyTuple_GET_SIZE(constant);

        APPEND_STR("(");

        for (i = 0; i < elem_count; i++) {

  Branch (731:21): [True: 0, False: 0]

            APPEND_STR_IF(i > 0, ", ");

            if (append_ast_constant(writer, PyTuple_GET_ITEM(constant, i)) < 0) {

  Branch (733:17): [True: 0, False: 0]

                return -1;

            }

        }

        APPEND_STR_IF(elem_count == 1, ",");

        APPEND_STR(")");

        return 0;

    }

    return append_repr(writer, constant);

}

static int

append_ast_attribute(_PyUnicodeWriter *writer, expr_ty e)

{

    const char *period;

    expr_ty v = e->v.Attribute.value;

    APPEND_EXPR(v, PR_ATOM);

    /* Special case: integers require a space for attribute access to be

       unambiguous. */

    if (v->kind == Constant_kind && 
PyLong_CheckExact21
(v->v.Constant.value)) {

  Branch (754:9): [True: 21, False: 35]

        period = " .";

    }

    else {

        period = ".";

    }

    APPEND_STR(period);

    return _PyUnicodeWriter_WriteStr(writer, e->v.Attribute.attr);

}

static int

append_ast_slice(_PyUnicodeWriter *writer, expr_ty e)

{

    if (e->v.Slice.lower) {

  Branch (768:9): [True: 91, False: 28]

        APPEND_EXPR(e->v.Slice.lower, PR_TEST);

    }

    APPEND_STR(":");

    if (e->v.Slice.upper) {

  Branch (774:9): [True: 91, False: 28]

        APPEND_EXPR(e->v.Slice.upper, PR_TEST);

    }

    if (e->v.Slice.step) {

  Branch (778:9): [True: 28, False: 91]

        APPEND_STR(":");

        APPEND_EXPR(e->v.Slice.step, PR_TEST);

    }

    return 0;

}

static int

append_ast_subscript(_PyUnicodeWriter *writer, expr_ty e)

{

    APPEND_EXPR(e->v.Subscript.value, PR_ATOM);

    APPEND_STR("[");

    APPEND_EXPR(e->v.Subscript.slice, PR_TUPLE);

    APPEND_STR_FINISH("]");

}

static int

append_ast_starred(_PyUnicodeWriter *writer, expr_ty e)

{

    APPEND_STR("*");

    APPEND_EXPR(e->v.Starred.value, PR_EXPR);

    return 0;

}

static int

append_ast_yield(_PyUnicodeWriter *writer, expr_ty e)

{

    if (!e->v.Yield.value) {

  Branch (805:9): [True: 0, False: 0]

        APPEND_STR_FINISH("(yield)");

    }

    APPEND_STR("(yield ");

    APPEND_EXPR(e->v.Yield.value, PR_TEST);

    APPEND_STR_FINISH(")");

}

static int

append_ast_yield_from(_PyUnicodeWriter *writer, expr_ty e)

{

    APPEND_STR("(yield from ");

    APPEND_EXPR(e->v.YieldFrom.value, PR_TEST);

    APPEND_STR_FINISH(")");

}

static int

append_ast_await(_PyUnicodeWriter *writer, expr_ty e, int level)

{

    APPEND_STR_IF(level > PR_AWAIT, "(");

    APPEND_STR("await ");

    APPEND_EXPR(e->v.Await.value, PR_ATOM);

    APPEND_STR_IF(level > PR_AWAIT, ")");

    return 0;

}

static int

append_named_expr(_PyUnicodeWriter *writer, expr_ty e, int level)

{

    APPEND_STR_IF(level > PR_TUPLE, "(");

    APPEND_EXPR(e->v.NamedExpr.target, PR_ATOM);

    APPEND_STR(" := ");

    APPEND_EXPR(e->v.NamedExpr.value, PR_ATOM);

    APPEND_STR_IF(level > PR_TUPLE, ")");

    return 0;

}

static int

append_ast_expr(_PyUnicodeWriter *writer, expr_ty e, int level)

{

    switch (e->kind) {

  Branch (846:13): [True: 0, False: 7.21k]

    case BoolOp_kind:

  Branch (847:5): [True: 224, False: 6.98k]

        return append_ast_boolop(writer, e, level);

    case BinOp_kind:

  Branch (849:5): [True: 441, False: 6.77k]

        return append_ast_binop(writer, e, level);

    case UnaryOp_kind:

  Branch (851:5): [True: 126, False: 7.08k]

        return append_ast_unaryop(writer, e, level);

    case Lambda_kind:

  Branch (853:5): [True: 154, False: 7.05k]

        return append_ast_lambda(writer, e, level);

    case IfExp_kind:

  Branch (855:5): [True: 91, False: 7.12k]

        return append_ast_ifexp(writer, e, level);

    case Dict_kind:

  Branch (857:5): [True: 35, False: 7.17k]

        return append_ast_dict(writer, e);

    case Set_kind:

  Branch (859:5): [True: 14, False: 7.19k]

        return append_ast_set(writer, e);

    case GeneratorExp_kind:

  Branch (861:5): [True: 49, False: 7.16k]

        return append_ast_genexp(writer, e);

    case ListComp_kind:

  Branch (863:5): [True: 56, False: 7.15k]

        return append_ast_listcomp(writer, e);

    case SetComp_kind:

  Branch (865:5): [True: 35, False: 7.17k]

        return append_ast_setcomp(writer, e);

    case DictComp_kind:

  Branch (867:5): [True: 14, False: 7.19k]

        return append_ast_dictcomp(writer, e);

    case Yield_kind:

  Branch (869:5): [True: 0, False: 7.21k]

        return append_ast_yield(writer, e);

    case YieldFrom_kind:

  Branch (871:5): [True: 0, False: 7.21k]

        return append_ast_yield_from(writer, e);

    case Await_kind:

  Branch (873:5): [True: 0, False: 7.21k]

        return append_ast_await(writer, e, level);

    case Compare_kind:

  Branch (875:5): [True: 35, False: 7.17k]

        return append_ast_compare(writer, e, level);

    case Call_kind:

  Branch (877:5): [True: 77, False: 7.13k]

        return append_ast_call(writer, e);

    case Constant_kind:

  Branch (879:5): [True: 2.15k, False: 5.05k]

        if (e->v.Constant.value == Py_Ellipsis) {

  Branch (880:13): [True: 21, False: 2.13k]

            APPEND_STR_FINISH("...");

        }

        if (e->v.Constant.kind != NULL

  Branch (883:13): [True: 7, False: 2.13k]

            && 
-1 == _PyUnicodeWriter_WriteStr(writer, e->v.Constant.kind)7
) {

  Branch (884:16): [True: 0, False: 7]

            return -1;

        }

        return append_ast_constant(writer, e->v.Constant.value);

    case JoinedStr_kind:

  Branch (888:5): [True: 119, False: 7.09k]

        return append_joinedstr(writer, e, false);

    case FormattedValue_kind:

  Branch (890:5): [True: 0, False: 7.21k]

        return append_formattedvalue(writer, e);

    /* The following exprs can be assignment targets. */

    case Attribute_kind:

  Branch (893:5): [True: 56, False: 7.15k]

        return append_ast_attribute(writer, e);

    case Subscript_kind:

  Branch (895:5): [True: 268, False: 6.94k]

        return append_ast_subscript(writer, e);

    case Starred_kind:

  Branch (897:5): [True: 204, False: 7.00k]

        return append_ast_starred(writer, e);

    case Slice_kind:

  Branch (899:5): [True: 119, False: 7.09k]

        return append_ast_slice(writer, e);

    case Name_kind:

  Branch (901:5): [True: 2.34k, False: 4.87k]

        return _PyUnicodeWriter_WriteStr(writer, e->v.Name.id);

    case List_kind:

  Branch (903:5): [True: 21, False: 7.19k]

        return append_ast_list(writer, e);

    case Tuple_kind:

  Branch (905:5): [True: 574, False: 6.63k]

        return append_ast_tuple(writer, e, level);

    case NamedExpr_kind:

  Branch (907:5): [True: 0, False: 7.21k]

        return append_named_expr(writer, e, level);

    // No default so compiler emits a warning for unhandled cases

    }

    PyErr_SetString(PyExc_SystemError,

                    "unknown expression kind");

    return -1;

}

static int

maybe_init_static_strings(void)

{

    if (!_str_replace_inf &&

  Branch (919:9): [True: 1, False: 1.66k]

        
!(_str_replace_inf = PyUnicode_FromFormat("1e%d", 1 + DBL_MAX_10_EXP))1
) {

  Branch (920:9): [True: 0, False: 1]

        return -1;

    }

    return 0;

}

static PyObject *

expr_as_unicode(expr_ty e, int level)

{

    _PyUnicodeWriter writer;

    _PyUnicodeWriter_Init(&writer);

    writer.min_length = 256;

    writer.overallocate = 1;

    if (-1 == maybe_init_static_strings() ||

  Branch (933:9): [True: 0, False: 1.66k]

        -1 == append_ast_expr(&writer, e, level))

  Branch (934:9): [True: 0, False: 1.66k]

    {

        _PyUnicodeWriter_Dealloc(&writer);

        return NULL;

    }

    return _PyUnicodeWriter_Finish(&writer);

}

PyObject *

_PyAST_ExprAsUnicode(expr_ty e)

{

    return expr_as_unicode(e, PR_TEST);

}