LCOV - code coverage report
Current view: top level - Python - ast_unparse.c (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 0 501 0.0 %
Date: 2023-03-20 08:15:36 Functions: 0 41 0.0 %
Branches: 0 566 0.0 %

           Branch data     Line data    Source code
       1                 :            : #include "Python.h"
       2                 :            : #include "pycore_ast.h"           // expr_ty
       3                 :            : #include "pycore_pystate.h"       // _PyInterpreterState_GET()
       4                 :            : #include "pycore_runtime.h"       // _Py_ID()
       5                 :            : #include <float.h>                // DBL_MAX_10_EXP
       6                 :            : #include <stdbool.h>
       7                 :            : 
       8                 :            : /* This limited unparser is used to convert annotations back to strings
       9                 :            :  * during compilation rather than being a full AST unparser.
      10                 :            :  * See ast.unparse for a full unparser (written in Python)
      11                 :            :  */
      12                 :            : 
      13                 :            : _Py_DECLARE_STR(open_br, "{");
      14                 :            : _Py_DECLARE_STR(dbl_open_br, "{{");
      15                 :            : _Py_DECLARE_STR(close_br, "}");
      16                 :            : _Py_DECLARE_STR(dbl_close_br, "}}");
      17                 :            : 
      18                 :            : /* We would statically initialize this if doing so were simple enough. */
      19                 :            : #define _str_replace_inf(interp) \
      20                 :            :     _Py_INTERP_CACHED_OBJECT(interp, str_replace_inf)
      21                 :            : 
      22                 :            : /* Forward declarations for recursion via helper functions. */
      23                 :            : static PyObject *
      24                 :            : expr_as_unicode(expr_ty e, int level);
      25                 :            : static int
      26                 :            : append_ast_expr(_PyUnicodeWriter *writer, expr_ty e, int level);
      27                 :            : static int
      28                 :            : append_joinedstr(_PyUnicodeWriter *writer, expr_ty e, bool is_format_spec);
      29                 :            : static int
      30                 :            : append_formattedvalue(_PyUnicodeWriter *writer, expr_ty e);
      31                 :            : static int
      32                 :            : append_ast_slice(_PyUnicodeWriter *writer, expr_ty e);
      33                 :            : 
      34                 :            : static int
      35                 :          0 : append_charp(_PyUnicodeWriter *writer, const char *charp)
      36                 :            : {
      37                 :          0 :     return _PyUnicodeWriter_WriteASCIIString(writer, charp, -1);
      38                 :            : }
      39                 :            : 
      40                 :            : #define APPEND_STR_FINISH(str)  do { \
      41                 :            :         return append_charp(writer, (str)); \
      42                 :            :     } while (0)
      43                 :            : 
      44                 :            : #define APPEND_STR(str)  do { \
      45                 :            :         if (-1 == append_charp(writer, (str))) { \
      46                 :            :             return -1; \
      47                 :            :         } \
      48                 :            :     } while (0)
      49                 :            : 
      50                 :            : #define APPEND_STR_IF(cond, str)  do { \
      51                 :            :         if ((cond) && -1 == append_charp(writer, (str))) { \
      52                 :            :             return -1; \
      53                 :            :         } \
      54                 :            :     } while (0)
      55                 :            : 
      56                 :            : #define APPEND_STR_IF_NOT_FIRST(str)  do { \
      57                 :            :         APPEND_STR_IF(!first, (str)); \
      58                 :            :         first = false; \
      59                 :            :     } while (0)
      60                 :            : 
      61                 :            : #define APPEND_EXPR(expr, pr)  do { \
      62                 :            :         if (-1 == append_ast_expr(writer, (expr), (pr))) { \
      63                 :            :             return -1; \
      64                 :            :         } \
      65                 :            :     } while (0)
      66                 :            : 
      67                 :            : #define APPEND(type, value)  do { \
      68                 :            :         if (-1 == append_ast_ ## type(writer, (value))) { \
      69                 :            :             return -1; \
      70                 :            :         } \
      71                 :            :     } while (0)
      72                 :            : 
      73                 :            : static int
      74                 :          0 : append_repr(_PyUnicodeWriter *writer, PyObject *obj)
      75                 :            : {
      76                 :          0 :     PyObject *repr = PyObject_Repr(obj);
      77                 :            : 
      78         [ #  # ]:          0 :     if (!repr) {
      79                 :          0 :         return -1;
      80                 :            :     }
      81                 :            : 
      82   [ #  #  #  #  :          0 :     if ((PyFloat_CheckExact(obj) && Py_IS_INFINITY(PyFloat_AS_DOUBLE(obj))) ||
                   #  # ]
      83                 :          0 :        PyComplex_CheckExact(obj))
      84                 :            :     {
      85                 :          0 :         PyInterpreterState *interp = _PyInterpreterState_GET();
      86                 :          0 :         PyObject *new_repr = PyUnicode_Replace(
      87                 :            :             repr,
      88                 :            :             &_Py_ID(inf),
      89                 :            :             _str_replace_inf(interp),
      90                 :            :             -1
      91                 :            :         );
      92                 :          0 :         Py_DECREF(repr);
      93         [ #  # ]:          0 :         if (!new_repr) {
      94                 :          0 :             return -1;
      95                 :            :         }
      96                 :          0 :         repr = new_repr;
      97                 :            :     }
      98                 :          0 :     int ret = _PyUnicodeWriter_WriteStr(writer, repr);
      99                 :          0 :     Py_DECREF(repr);
     100                 :          0 :     return ret;
     101                 :            : }
     102                 :            : 
     103                 :            : /* Priority levels */
     104                 :            : 
     105                 :            : enum {
     106                 :            :     PR_TUPLE,
     107                 :            :     PR_TEST,            /* 'if'-'else', 'lambda' */
     108                 :            :     PR_OR,              /* 'or' */
     109                 :            :     PR_AND,             /* 'and' */
     110                 :            :     PR_NOT,             /* 'not' */
     111                 :            :     PR_CMP,             /* '<', '>', '==', '>=', '<=', '!=',
     112                 :            :                            'in', 'not in', 'is', 'is not' */
     113                 :            :     PR_EXPR,
     114                 :            :     PR_BOR = PR_EXPR,   /* '|' */
     115                 :            :     PR_BXOR,            /* '^' */
     116                 :            :     PR_BAND,            /* '&' */
     117                 :            :     PR_SHIFT,           /* '<<', '>>' */
     118                 :            :     PR_ARITH,           /* '+', '-' */
     119                 :            :     PR_TERM,            /* '*', '@', '/', '%', '//' */
     120                 :            :     PR_FACTOR,          /* unary '+', '-', '~' */
     121                 :            :     PR_POWER,           /* '**' */
     122                 :            :     PR_AWAIT,           /* 'await' */
     123                 :            :     PR_ATOM,
     124                 :            : };
     125                 :            : 
     126                 :            : static int
     127                 :          0 : append_ast_boolop(_PyUnicodeWriter *writer, expr_ty e, int level)
     128                 :            : {
     129                 :            :     Py_ssize_t i, value_count;
     130                 :            :     asdl_expr_seq *values;
     131         [ #  # ]:          0 :     const char *op = (e->v.BoolOp.op == And) ? " and " : " or ";
     132         [ #  # ]:          0 :     int pr = (e->v.BoolOp.op == And) ? PR_AND : PR_OR;
     133                 :            : 
     134   [ #  #  #  # ]:          0 :     APPEND_STR_IF(level > pr, "(");
     135                 :            : 
     136                 :          0 :     values = e->v.BoolOp.values;
     137         [ #  # ]:          0 :     value_count = asdl_seq_LEN(values);
     138                 :            : 
     139         [ #  # ]:          0 :     for (i = 0; i < value_count; ++i) {
     140   [ #  #  #  # ]:          0 :         APPEND_STR_IF(i > 0, op);
     141         [ #  # ]:          0 :         APPEND_EXPR((expr_ty)asdl_seq_GET(values, i), pr + 1);
     142                 :            :     }
     143                 :            : 
     144   [ #  #  #  # ]:          0 :     APPEND_STR_IF(level > pr, ")");
     145                 :          0 :     return 0;
     146                 :            : }
     147                 :            : 
     148                 :            : static int
     149                 :          0 : append_ast_binop(_PyUnicodeWriter *writer, expr_ty e, int level)
     150                 :            : {
     151                 :            :     const char *op;
     152                 :            :     int pr;
     153                 :          0 :     bool rassoc = false;  /* is right-associative? */
     154                 :            : 
     155   [ #  #  #  #  :          0 :     switch (e->v.BinOp.op) {
          #  #  #  #  #  
             #  #  #  #  
                      # ]
     156                 :          0 :     case Add: op = " + "; pr = PR_ARITH; break;
     157                 :          0 :     case Sub: op = " - "; pr = PR_ARITH; break;
     158                 :          0 :     case Mult: op = " * "; pr = PR_TERM; break;
     159                 :          0 :     case MatMult: op = " @ "; pr = PR_TERM; break;
     160                 :          0 :     case Div: op = " / "; pr = PR_TERM; break;
     161                 :          0 :     case Mod: op = " % "; pr = PR_TERM; break;
     162                 :          0 :     case LShift: op = " << "; pr = PR_SHIFT; break;
     163                 :          0 :     case RShift: op = " >> "; pr = PR_SHIFT; break;
     164                 :          0 :     case BitOr: op = " | "; pr = PR_BOR; break;
     165                 :          0 :     case BitXor: op = " ^ "; pr = PR_BXOR; break;
     166                 :          0 :     case BitAnd: op = " & "; pr = PR_BAND; break;
     167                 :          0 :     case FloorDiv: op = " // "; pr = PR_TERM; break;
     168                 :          0 :     case Pow: op = " ** "; pr = PR_POWER; rassoc = true; break;
     169                 :          0 :     default:
     170                 :          0 :         PyErr_SetString(PyExc_SystemError,
     171                 :            :                         "unknown binary operator");
     172                 :          0 :         return -1;
     173                 :            :     }
     174                 :            : 
     175   [ #  #  #  # ]:          0 :     APPEND_STR_IF(level > pr, "(");
     176         [ #  # ]:          0 :     APPEND_EXPR(e->v.BinOp.left, pr + rassoc);
     177         [ #  # ]:          0 :     APPEND_STR(op);
     178         [ #  # ]:          0 :     APPEND_EXPR(e->v.BinOp.right, pr + !rassoc);
     179   [ #  #  #  # ]:          0 :     APPEND_STR_IF(level > pr, ")");
     180                 :          0 :     return 0;
     181                 :            : }
     182                 :            : 
     183                 :            : static int
     184                 :          0 : append_ast_unaryop(_PyUnicodeWriter *writer, expr_ty e, int level)
     185                 :            : {
     186                 :            :     const char *op;
     187                 :            :     int pr;
     188                 :            : 
     189   [ #  #  #  #  :          0 :     switch (e->v.UnaryOp.op) {
                      # ]
     190                 :          0 :     case Invert: op = "~"; pr = PR_FACTOR; break;
     191                 :          0 :     case Not: op = "not "; pr = PR_NOT; break;
     192                 :          0 :     case UAdd: op = "+"; pr = PR_FACTOR; break;
     193                 :          0 :     case USub: op = "-"; pr = PR_FACTOR; break;
     194                 :          0 :     default:
     195                 :          0 :         PyErr_SetString(PyExc_SystemError,
     196                 :            :                         "unknown unary operator");
     197                 :          0 :         return -1;
     198                 :            :     }
     199                 :            : 
     200   [ #  #  #  # ]:          0 :     APPEND_STR_IF(level > pr, "(");
     201         [ #  # ]:          0 :     APPEND_STR(op);
     202         [ #  # ]:          0 :     APPEND_EXPR(e->v.UnaryOp.operand, pr);
     203   [ #  #  #  # ]:          0 :     APPEND_STR_IF(level > pr, ")");
     204                 :          0 :     return 0;
     205                 :            : }
     206                 :            : 
     207                 :            : static int
     208                 :          0 : append_ast_arg(_PyUnicodeWriter *writer, arg_ty arg)
     209                 :            : {
     210         [ #  # ]:          0 :     if (-1 == _PyUnicodeWriter_WriteStr(writer, arg->arg)) {
     211                 :          0 :         return -1;
     212                 :            :     }
     213         [ #  # ]:          0 :     if (arg->annotation) {
     214         [ #  # ]:          0 :         APPEND_STR(": ");
     215         [ #  # ]:          0 :         APPEND_EXPR(arg->annotation, PR_TEST);
     216                 :            :     }
     217                 :          0 :     return 0;
     218                 :            : }
     219                 :            : 
     220                 :            : static int
     221                 :          0 : append_ast_args(_PyUnicodeWriter *writer, arguments_ty args)
     222                 :            : {
     223                 :            :     bool first;
     224                 :            :     Py_ssize_t i, di, arg_count, posonlyarg_count, default_count;
     225                 :            : 
     226                 :          0 :     first = true;
     227                 :            : 
     228                 :            :     /* positional-only and positional arguments with defaults */
     229         [ #  # ]:          0 :     posonlyarg_count = asdl_seq_LEN(args->posonlyargs);
     230         [ #  # ]:          0 :     arg_count = asdl_seq_LEN(args->args);
     231         [ #  # ]:          0 :     default_count = asdl_seq_LEN(args->defaults);
     232         [ #  # ]:          0 :     for (i = 0; i < posonlyarg_count + arg_count; i++) {
     233   [ #  #  #  # ]:          0 :         APPEND_STR_IF_NOT_FIRST(", ");
     234         [ #  # ]:          0 :         if (i < posonlyarg_count){
     235         [ #  # ]:          0 :             APPEND(arg, (arg_ty)asdl_seq_GET(args->posonlyargs, i));
     236                 :            :         } else {
     237         [ #  # ]:          0 :             APPEND(arg, (arg_ty)asdl_seq_GET(args->args, i-posonlyarg_count));
     238                 :            :         }
     239                 :            : 
     240                 :          0 :         di = i - posonlyarg_count - arg_count + default_count;
     241         [ #  # ]:          0 :         if (di >= 0) {
     242         [ #  # ]:          0 :             APPEND_STR("=");
     243         [ #  # ]:          0 :             APPEND_EXPR((expr_ty)asdl_seq_GET(args->defaults, di), PR_TEST);
     244                 :            :         }
     245   [ #  #  #  # ]:          0 :         if (posonlyarg_count && i + 1 == posonlyarg_count) {
     246         [ #  # ]:          0 :             APPEND_STR(", /");
     247                 :            :         }
     248                 :            :     }
     249                 :            : 
     250                 :            :     /* vararg, or bare '*' if no varargs but keyword-only arguments present */
     251   [ #  #  #  #  :          0 :     if (args->vararg || asdl_seq_LEN(args->kwonlyargs)) {
                   #  # ]
     252   [ #  #  #  # ]:          0 :         APPEND_STR_IF_NOT_FIRST(", ");
     253         [ #  # ]:          0 :         APPEND_STR("*");
     254         [ #  # ]:          0 :         if (args->vararg) {
     255         [ #  # ]:          0 :             APPEND(arg, args->vararg);
     256                 :            :         }
     257                 :            :     }
     258                 :            : 
     259                 :            :     /* keyword-only arguments */
     260         [ #  # ]:          0 :     arg_count = asdl_seq_LEN(args->kwonlyargs);
     261         [ #  # ]:          0 :     default_count = asdl_seq_LEN(args->kw_defaults);
     262         [ #  # ]:          0 :     for (i = 0; i < arg_count; i++) {
     263   [ #  #  #  # ]:          0 :         APPEND_STR_IF_NOT_FIRST(", ");
     264         [ #  # ]:          0 :         APPEND(arg, (arg_ty)asdl_seq_GET(args->kwonlyargs, i));
     265                 :            : 
     266                 :          0 :         di = i - arg_count + default_count;
     267         [ #  # ]:          0 :         if (di >= 0) {
     268                 :          0 :             expr_ty default_ = (expr_ty)asdl_seq_GET(args->kw_defaults, di);
     269         [ #  # ]:          0 :             if (default_) {
     270         [ #  # ]:          0 :                 APPEND_STR("=");
     271         [ #  # ]:          0 :                 APPEND_EXPR(default_, PR_TEST);
     272                 :            :             }
     273                 :            :         }
     274                 :            :     }
     275                 :            : 
     276                 :            :     /* **kwargs */
     277         [ #  # ]:          0 :     if (args->kwarg) {
     278   [ #  #  #  # ]:          0 :         APPEND_STR_IF_NOT_FIRST(", ");
     279         [ #  # ]:          0 :         APPEND_STR("**");
     280         [ #  # ]:          0 :         APPEND(arg, args->kwarg);
     281                 :            :     }
     282                 :            : 
     283                 :          0 :     return 0;
     284                 :            : }
     285                 :            : 
     286                 :            : static int
     287                 :          0 : append_ast_lambda(_PyUnicodeWriter *writer, expr_ty e, int level)
     288                 :            : {
     289   [ #  #  #  # ]:          0 :     APPEND_STR_IF(level > PR_TEST, "(");
     290         [ #  # ]:          0 :     Py_ssize_t n_positional = (asdl_seq_LEN(e->v.Lambda.args->args) +
     291         [ #  # ]:          0 :                                asdl_seq_LEN(e->v.Lambda.args->posonlyargs));
     292   [ #  #  #  # ]:          0 :     APPEND_STR(n_positional ? "lambda " : "lambda");
     293         [ #  # ]:          0 :     APPEND(args, e->v.Lambda.args);
     294         [ #  # ]:          0 :     APPEND_STR(": ");
     295         [ #  # ]:          0 :     APPEND_EXPR(e->v.Lambda.body, PR_TEST);
     296   [ #  #  #  # ]:          0 :     APPEND_STR_IF(level > PR_TEST, ")");
     297                 :          0 :     return 0;
     298                 :            : }
     299                 :            : 
     300                 :            : static int
     301                 :          0 : append_ast_ifexp(_PyUnicodeWriter *writer, expr_ty e, int level)
     302                 :            : {
     303   [ #  #  #  # ]:          0 :     APPEND_STR_IF(level > PR_TEST, "(");
     304         [ #  # ]:          0 :     APPEND_EXPR(e->v.IfExp.body, PR_TEST + 1);
     305         [ #  # ]:          0 :     APPEND_STR(" if ");
     306         [ #  # ]:          0 :     APPEND_EXPR(e->v.IfExp.test, PR_TEST + 1);
     307         [ #  # ]:          0 :     APPEND_STR(" else ");
     308         [ #  # ]:          0 :     APPEND_EXPR(e->v.IfExp.orelse, PR_TEST);
     309   [ #  #  #  # ]:          0 :     APPEND_STR_IF(level > PR_TEST, ")");
     310                 :          0 :     return 0;
     311                 :            : }
     312                 :            : 
     313                 :            : static int
     314                 :          0 : append_ast_dict(_PyUnicodeWriter *writer, expr_ty e)
     315                 :            : {
     316                 :            :     Py_ssize_t i, value_count;
     317                 :            :     expr_ty key_node;
     318                 :            : 
     319         [ #  # ]:          0 :     APPEND_STR("{");
     320         [ #  # ]:          0 :     value_count = asdl_seq_LEN(e->v.Dict.values);
     321                 :            : 
     322         [ #  # ]:          0 :     for (i = 0; i < value_count; i++) {
     323   [ #  #  #  # ]:          0 :         APPEND_STR_IF(i > 0, ", ");
     324                 :          0 :         key_node = (expr_ty)asdl_seq_GET(e->v.Dict.keys, i);
     325         [ #  # ]:          0 :         if (key_node != NULL) {
     326         [ #  # ]:          0 :             APPEND_EXPR(key_node, PR_TEST);
     327         [ #  # ]:          0 :             APPEND_STR(": ");
     328         [ #  # ]:          0 :             APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.Dict.values, i), PR_TEST);
     329                 :            :         }
     330                 :            :         else {
     331         [ #  # ]:          0 :             APPEND_STR("**");
     332         [ #  # ]:          0 :             APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.Dict.values, i), PR_EXPR);
     333                 :            :         }
     334                 :            :     }
     335                 :            : 
     336                 :          0 :     APPEND_STR_FINISH("}");
     337                 :            : }
     338                 :            : 
     339                 :            : static int
     340                 :          0 : append_ast_set(_PyUnicodeWriter *writer, expr_ty e)
     341                 :            : {
     342                 :            :     Py_ssize_t i, elem_count;
     343                 :            : 
     344         [ #  # ]:          0 :     APPEND_STR("{");
     345         [ #  # ]:          0 :     elem_count = asdl_seq_LEN(e->v.Set.elts);
     346         [ #  # ]:          0 :     for (i = 0; i < elem_count; i++) {
     347   [ #  #  #  # ]:          0 :         APPEND_STR_IF(i > 0, ", ");
     348         [ #  # ]:          0 :         APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.Set.elts, i), PR_TEST);
     349                 :            :     }
     350                 :            : 
     351                 :          0 :     APPEND_STR_FINISH("}");
     352                 :            : }
     353                 :            : 
     354                 :            : static int
     355                 :          0 : append_ast_list(_PyUnicodeWriter *writer, expr_ty e)
     356                 :            : {
     357                 :            :     Py_ssize_t i, elem_count;
     358                 :            : 
     359         [ #  # ]:          0 :     APPEND_STR("[");
     360         [ #  # ]:          0 :     elem_count = asdl_seq_LEN(e->v.List.elts);
     361         [ #  # ]:          0 :     for (i = 0; i < elem_count; i++) {
     362   [ #  #  #  # ]:          0 :         APPEND_STR_IF(i > 0, ", ");
     363         [ #  # ]:          0 :         APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.List.elts, i), PR_TEST);
     364                 :            :     }
     365                 :            : 
     366                 :          0 :     APPEND_STR_FINISH("]");
     367                 :            : }
     368                 :            : 
     369                 :            : static int
     370                 :          0 : append_ast_tuple(_PyUnicodeWriter *writer, expr_ty e, int level)
     371                 :            : {
     372                 :            :     Py_ssize_t i, elem_count;
     373                 :            : 
     374         [ #  # ]:          0 :     elem_count = asdl_seq_LEN(e->v.Tuple.elts);
     375                 :            : 
     376         [ #  # ]:          0 :     if (elem_count == 0) {
     377                 :          0 :         APPEND_STR_FINISH("()");
     378                 :            :     }
     379                 :            : 
     380   [ #  #  #  # ]:          0 :     APPEND_STR_IF(level > PR_TUPLE, "(");
     381                 :            : 
     382         [ #  # ]:          0 :     for (i = 0; i < elem_count; i++) {
     383   [ #  #  #  # ]:          0 :         APPEND_STR_IF(i > 0, ", ");
     384         [ #  # ]:          0 :         APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.Tuple.elts, i), PR_TEST);
     385                 :            :     }
     386                 :            : 
     387   [ #  #  #  # ]:          0 :     APPEND_STR_IF(elem_count == 1, ",");
     388   [ #  #  #  # ]:          0 :     APPEND_STR_IF(level > PR_TUPLE, ")");
     389                 :          0 :     return 0;
     390                 :            : }
     391                 :            : 
     392                 :            : static int
     393                 :          0 : append_ast_comprehension(_PyUnicodeWriter *writer, comprehension_ty gen)
     394                 :            : {
     395                 :            :     Py_ssize_t i, if_count;
     396                 :            : 
     397   [ #  #  #  # ]:          0 :     APPEND_STR(gen->is_async ? " async for " : " for ");
     398         [ #  # ]:          0 :     APPEND_EXPR(gen->target, PR_TUPLE);
     399         [ #  # ]:          0 :     APPEND_STR(" in ");
     400         [ #  # ]:          0 :     APPEND_EXPR(gen->iter, PR_TEST + 1);
     401                 :            : 
     402         [ #  # ]:          0 :     if_count = asdl_seq_LEN(gen->ifs);
     403         [ #  # ]:          0 :     for (i = 0; i < if_count; i++) {
     404         [ #  # ]:          0 :         APPEND_STR(" if ");
     405         [ #  # ]:          0 :         APPEND_EXPR((expr_ty)asdl_seq_GET(gen->ifs, i), PR_TEST + 1);
     406                 :            :     }
     407                 :          0 :     return 0;
     408                 :            : }
     409                 :            : 
     410                 :            : static int
     411                 :          0 : append_ast_comprehensions(_PyUnicodeWriter *writer, asdl_comprehension_seq *comprehensions)
     412                 :            : {
     413                 :            :     Py_ssize_t i, gen_count;
     414         [ #  # ]:          0 :     gen_count = asdl_seq_LEN(comprehensions);
     415                 :            : 
     416         [ #  # ]:          0 :     for (i = 0; i < gen_count; i++) {
     417         [ #  # ]:          0 :         APPEND(comprehension, (comprehension_ty)asdl_seq_GET(comprehensions, i));
     418                 :            :     }
     419                 :            : 
     420                 :          0 :     return 0;
     421                 :            : }
     422                 :            : 
     423                 :            : static int
     424                 :          0 : append_ast_genexp(_PyUnicodeWriter *writer, expr_ty e)
     425                 :            : {
     426         [ #  # ]:          0 :     APPEND_STR("(");
     427         [ #  # ]:          0 :     APPEND_EXPR(e->v.GeneratorExp.elt, PR_TEST);
     428         [ #  # ]:          0 :     APPEND(comprehensions, e->v.GeneratorExp.generators);
     429                 :          0 :     APPEND_STR_FINISH(")");
     430                 :            : }
     431                 :            : 
     432                 :            : static int
     433                 :          0 : append_ast_listcomp(_PyUnicodeWriter *writer, expr_ty e)
     434                 :            : {
     435         [ #  # ]:          0 :     APPEND_STR("[");
     436         [ #  # ]:          0 :     APPEND_EXPR(e->v.ListComp.elt, PR_TEST);
     437         [ #  # ]:          0 :     APPEND(comprehensions, e->v.ListComp.generators);
     438                 :          0 :     APPEND_STR_FINISH("]");
     439                 :            : }
     440                 :            : 
     441                 :            : static int
     442                 :          0 : append_ast_setcomp(_PyUnicodeWriter *writer, expr_ty e)
     443                 :            : {
     444         [ #  # ]:          0 :     APPEND_STR("{");
     445         [ #  # ]:          0 :     APPEND_EXPR(e->v.SetComp.elt, PR_TEST);
     446         [ #  # ]:          0 :     APPEND(comprehensions, e->v.SetComp.generators);
     447                 :          0 :     APPEND_STR_FINISH("}");
     448                 :            : }
     449                 :            : 
     450                 :            : static int
     451                 :          0 : append_ast_dictcomp(_PyUnicodeWriter *writer, expr_ty e)
     452                 :            : {
     453         [ #  # ]:          0 :     APPEND_STR("{");
     454         [ #  # ]:          0 :     APPEND_EXPR(e->v.DictComp.key, PR_TEST);
     455         [ #  # ]:          0 :     APPEND_STR(": ");
     456         [ #  # ]:          0 :     APPEND_EXPR(e->v.DictComp.value, PR_TEST);
     457         [ #  # ]:          0 :     APPEND(comprehensions, e->v.DictComp.generators);
     458                 :          0 :     APPEND_STR_FINISH("}");
     459                 :            : }
     460                 :            : 
     461                 :            : static int
     462                 :          0 : append_ast_compare(_PyUnicodeWriter *writer, expr_ty e, int level)
     463                 :            : {
     464                 :            :     const char *op;
     465                 :            :     Py_ssize_t i, comparator_count;
     466                 :            :     asdl_expr_seq *comparators;
     467                 :            :     asdl_int_seq *ops;
     468                 :            : 
     469   [ #  #  #  # ]:          0 :     APPEND_STR_IF(level > PR_CMP, "(");
     470                 :            : 
     471                 :          0 :     comparators = e->v.Compare.comparators;
     472                 :          0 :     ops = e->v.Compare.ops;
     473         [ #  # ]:          0 :     comparator_count = asdl_seq_LEN(comparators);
     474                 :            :     assert(comparator_count > 0);
     475                 :            :     assert(comparator_count == asdl_seq_LEN(ops));
     476                 :            : 
     477         [ #  # ]:          0 :     APPEND_EXPR(e->v.Compare.left, PR_CMP + 1);
     478                 :            : 
     479         [ #  # ]:          0 :     for (i = 0; i < comparator_count; i++) {
     480   [ #  #  #  #  :          0 :         switch ((cmpop_ty)asdl_seq_GET(ops, i)) {
          #  #  #  #  #  
                   #  # ]
     481                 :          0 :         case Eq:
     482                 :          0 :             op = " == ";
     483                 :          0 :             break;
     484                 :          0 :         case NotEq:
     485                 :          0 :             op = " != ";
     486                 :          0 :             break;
     487                 :          0 :         case Lt:
     488                 :          0 :             op = " < ";
     489                 :          0 :             break;
     490                 :          0 :         case LtE:
     491                 :          0 :             op = " <= ";
     492                 :          0 :             break;
     493                 :          0 :         case Gt:
     494                 :          0 :             op = " > ";
     495                 :          0 :             break;
     496                 :          0 :         case GtE:
     497                 :          0 :             op = " >= ";
     498                 :          0 :             break;
     499                 :          0 :         case Is:
     500                 :          0 :             op = " is ";
     501                 :          0 :             break;
     502                 :          0 :         case IsNot:
     503                 :          0 :             op = " is not ";
     504                 :          0 :             break;
     505                 :          0 :         case In:
     506                 :          0 :             op = " in ";
     507                 :          0 :             break;
     508                 :          0 :         case NotIn:
     509                 :          0 :             op = " not in ";
     510                 :          0 :             break;
     511                 :          0 :         default:
     512                 :          0 :             PyErr_SetString(PyExc_SystemError,
     513                 :            :                             "unexpected comparison kind");
     514                 :          0 :             return -1;
     515                 :            :         }
     516                 :            : 
     517         [ #  # ]:          0 :         APPEND_STR(op);
     518         [ #  # ]:          0 :         APPEND_EXPR((expr_ty)asdl_seq_GET(comparators, i), PR_CMP + 1);
     519                 :            :     }
     520                 :            : 
     521   [ #  #  #  # ]:          0 :     APPEND_STR_IF(level > PR_CMP, ")");
     522                 :          0 :     return 0;
     523                 :            : }
     524                 :            : 
     525                 :            : static int
     526                 :          0 : append_ast_keyword(_PyUnicodeWriter *writer, keyword_ty kw)
     527                 :            : {
     528         [ #  # ]:          0 :     if (kw->arg == NULL) {
     529         [ #  # ]:          0 :         APPEND_STR("**");
     530                 :            :     }
     531                 :            :     else {
     532         [ #  # ]:          0 :         if (-1 == _PyUnicodeWriter_WriteStr(writer, kw->arg)) {
     533                 :          0 :             return -1;
     534                 :            :         }
     535                 :            : 
     536         [ #  # ]:          0 :         APPEND_STR("=");
     537                 :            :     }
     538                 :            : 
     539         [ #  # ]:          0 :     APPEND_EXPR(kw->value, PR_TEST);
     540                 :          0 :     return 0;
     541                 :            : }
     542                 :            : 
     543                 :            : static int
     544                 :          0 : append_ast_call(_PyUnicodeWriter *writer, expr_ty e)
     545                 :            : {
     546                 :            :     bool first;
     547                 :            :     Py_ssize_t i, arg_count, kw_count;
     548                 :            :     expr_ty expr;
     549                 :            : 
     550         [ #  # ]:          0 :     APPEND_EXPR(e->v.Call.func, PR_ATOM);
     551                 :            : 
     552         [ #  # ]:          0 :     arg_count = asdl_seq_LEN(e->v.Call.args);
     553         [ #  # ]:          0 :     kw_count = asdl_seq_LEN(e->v.Call.keywords);
     554   [ #  #  #  # ]:          0 :     if (arg_count == 1 && kw_count == 0) {
     555                 :          0 :         expr = (expr_ty)asdl_seq_GET(e->v.Call.args, 0);
     556         [ #  # ]:          0 :         if (expr->kind == GeneratorExp_kind) {
     557                 :            :             /* Special case: a single generator expression. */
     558                 :          0 :             return append_ast_genexp(writer, expr);
     559                 :            :         }
     560                 :            :     }
     561                 :            : 
     562         [ #  # ]:          0 :     APPEND_STR("(");
     563                 :            : 
     564                 :          0 :     first = true;
     565         [ #  # ]:          0 :     for (i = 0; i < arg_count; i++) {
     566   [ #  #  #  # ]:          0 :         APPEND_STR_IF_NOT_FIRST(", ");
     567         [ #  # ]:          0 :         APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.Call.args, i), PR_TEST);
     568                 :            :     }
     569                 :            : 
     570         [ #  # ]:          0 :     for (i = 0; i < kw_count; i++) {
     571   [ #  #  #  # ]:          0 :         APPEND_STR_IF_NOT_FIRST(", ");
     572         [ #  # ]:          0 :         APPEND(keyword, (keyword_ty)asdl_seq_GET(e->v.Call.keywords, i));
     573                 :            :     }
     574                 :            : 
     575                 :          0 :     APPEND_STR_FINISH(")");
     576                 :            : }
     577                 :            : 
     578                 :            : static PyObject *
     579                 :          0 : escape_braces(PyObject *orig)
     580                 :            : {
     581                 :            :     PyObject *temp;
     582                 :            :     PyObject *result;
     583                 :          0 :     temp = PyUnicode_Replace(orig, &_Py_STR(open_br), &_Py_STR(dbl_open_br), -1);
     584         [ #  # ]:          0 :     if (!temp) {
     585                 :          0 :         return NULL;
     586                 :            :     }
     587                 :          0 :     result = PyUnicode_Replace(temp, &_Py_STR(close_br), &_Py_STR(dbl_close_br), -1);
     588                 :          0 :     Py_DECREF(temp);
     589                 :          0 :     return result;
     590                 :            : }
     591                 :            : 
     592                 :            : static int
     593                 :          0 : append_fstring_unicode(_PyUnicodeWriter *writer, PyObject *unicode)
     594                 :            : {
     595                 :            :     PyObject *escaped;
     596                 :          0 :     int result = -1;
     597                 :          0 :     escaped = escape_braces(unicode);
     598         [ #  # ]:          0 :     if (escaped) {
     599                 :          0 :         result = _PyUnicodeWriter_WriteStr(writer, escaped);
     600                 :          0 :         Py_DECREF(escaped);
     601                 :            :     }
     602                 :          0 :     return result;
     603                 :            : }
     604                 :            : 
     605                 :            : static int
     606                 :          0 : append_fstring_element(_PyUnicodeWriter *writer, expr_ty e, bool is_format_spec)
     607                 :            : {
     608   [ #  #  #  # ]:          0 :     switch (e->kind) {
     609                 :          0 :     case Constant_kind:
     610                 :          0 :         return append_fstring_unicode(writer, e->v.Constant.value);
     611                 :          0 :     case JoinedStr_kind:
     612                 :          0 :         return append_joinedstr(writer, e, is_format_spec);
     613                 :          0 :     case FormattedValue_kind:
     614                 :          0 :         return append_formattedvalue(writer, e);
     615                 :          0 :     default:
     616                 :          0 :         PyErr_SetString(PyExc_SystemError,
     617                 :            :                         "unknown expression kind inside f-string");
     618                 :          0 :         return -1;
     619                 :            :     }
     620                 :            : }
     621                 :            : 
     622                 :            : /* Build body separately to enable wrapping the entire stream of Strs,
     623                 :            :    Constants and FormattedValues in one opening and one closing quote. */
     624                 :            : static PyObject *
     625                 :          0 : build_fstring_body(asdl_expr_seq *values, bool is_format_spec)
     626                 :            : {
     627                 :            :     Py_ssize_t i, value_count;
     628                 :            :     _PyUnicodeWriter body_writer;
     629                 :          0 :     _PyUnicodeWriter_Init(&body_writer);
     630                 :          0 :     body_writer.min_length = 256;
     631                 :          0 :     body_writer.overallocate = 1;
     632                 :            : 
     633         [ #  # ]:          0 :     value_count = asdl_seq_LEN(values);
     634         [ #  # ]:          0 :     for (i = 0; i < value_count; ++i) {
     635         [ #  # ]:          0 :         if (-1 == append_fstring_element(&body_writer,
     636                 :          0 :                                          (expr_ty)asdl_seq_GET(values, i),
     637                 :            :                                          is_format_spec
     638                 :            :                                          )) {
     639                 :          0 :             _PyUnicodeWriter_Dealloc(&body_writer);
     640                 :          0 :             return NULL;
     641                 :            :         }
     642                 :            :     }
     643                 :            : 
     644                 :          0 :     return _PyUnicodeWriter_Finish(&body_writer);
     645                 :            : }
     646                 :            : 
     647                 :            : static int
     648                 :          0 : append_joinedstr(_PyUnicodeWriter *writer, expr_ty e, bool is_format_spec)
     649                 :            : {
     650                 :          0 :     int result = -1;
     651                 :          0 :     PyObject *body = build_fstring_body(e->v.JoinedStr.values, is_format_spec);
     652         [ #  # ]:          0 :     if (!body) {
     653                 :          0 :         return -1;
     654                 :            :     }
     655                 :            : 
     656         [ #  # ]:          0 :     if (!is_format_spec) {
     657   [ #  #  #  # ]:          0 :         if (-1 != append_charp(writer, "f") &&
     658                 :          0 :             -1 != append_repr(writer, body))
     659                 :            :         {
     660                 :          0 :             result = 0;
     661                 :            :         }
     662                 :            :     }
     663                 :            :     else {
     664                 :          0 :         result = _PyUnicodeWriter_WriteStr(writer, body);
     665                 :            :     }
     666                 :          0 :     Py_DECREF(body);
     667                 :          0 :     return result;
     668                 :            : }
     669                 :            : 
     670                 :            : static int
     671                 :          0 : append_formattedvalue(_PyUnicodeWriter *writer, expr_ty e)
     672                 :            : {
     673                 :            :     const char *conversion;
     674                 :          0 :     const char *outer_brace = "{";
     675                 :            :     /* Grammar allows PR_TUPLE, but use >PR_TEST for adding parenthesis
     676                 :            :        around a lambda with ':' */
     677                 :          0 :     PyObject *temp_fv_str = expr_as_unicode(e->v.FormattedValue.value, PR_TEST + 1);
     678         [ #  # ]:          0 :     if (!temp_fv_str) {
     679                 :          0 :         return -1;
     680                 :            :     }
     681         [ #  # ]:          0 :     if (PyUnicode_Find(temp_fv_str, &_Py_STR(open_br), 0, 1, 1) == 0) {
     682                 :            :         /* Expression starts with a brace, split it with a space from the outer
     683                 :            :            one. */
     684                 :          0 :         outer_brace = "{ ";
     685                 :            :     }
     686         [ #  # ]:          0 :     if (-1 == append_charp(writer, outer_brace)) {
     687                 :          0 :         Py_DECREF(temp_fv_str);
     688                 :          0 :         return -1;
     689                 :            :     }
     690         [ #  # ]:          0 :     if (-1 == _PyUnicodeWriter_WriteStr(writer, temp_fv_str)) {
     691                 :          0 :         Py_DECREF(temp_fv_str);
     692                 :          0 :         return -1;
     693                 :            :     }
     694                 :          0 :     Py_DECREF(temp_fv_str);
     695                 :            : 
     696         [ #  # ]:          0 :     if (e->v.FormattedValue.conversion > 0) {
     697   [ #  #  #  # ]:          0 :         switch (e->v.FormattedValue.conversion) {
     698                 :          0 :         case 'a':
     699                 :          0 :             conversion = "!a";
     700                 :          0 :             break;
     701                 :          0 :         case 'r':
     702                 :          0 :             conversion = "!r";
     703                 :          0 :             break;
     704                 :          0 :         case 's':
     705                 :          0 :             conversion = "!s";
     706                 :          0 :             break;
     707                 :          0 :         default:
     708                 :          0 :             PyErr_SetString(PyExc_SystemError,
     709                 :            :                             "unknown f-value conversion kind");
     710                 :          0 :             return -1;
     711                 :            :         }
     712         [ #  # ]:          0 :         APPEND_STR(conversion);
     713                 :            :     }
     714         [ #  # ]:          0 :     if (e->v.FormattedValue.format_spec) {
     715   [ #  #  #  # ]:          0 :         if (-1 == _PyUnicodeWriter_WriteASCIIString(writer, ":", 1) ||
     716                 :          0 :             -1 == append_fstring_element(writer,
     717                 :            :                                          e->v.FormattedValue.format_spec,
     718                 :            :                                          true
     719                 :            :                                         ))
     720                 :            :         {
     721                 :          0 :             return -1;
     722                 :            :         }
     723                 :            :     }
     724                 :            : 
     725                 :          0 :     APPEND_STR_FINISH("}");
     726                 :            : }
     727                 :            : 
     728                 :            : static int
     729                 :          0 : append_ast_constant(_PyUnicodeWriter *writer, PyObject *constant)
     730                 :            : {
     731         [ #  # ]:          0 :     if (PyTuple_CheckExact(constant)) {
     732                 :            :         Py_ssize_t i, elem_count;
     733                 :            : 
     734                 :          0 :         elem_count = PyTuple_GET_SIZE(constant);
     735         [ #  # ]:          0 :         APPEND_STR("(");
     736         [ #  # ]:          0 :         for (i = 0; i < elem_count; i++) {
     737   [ #  #  #  # ]:          0 :             APPEND_STR_IF(i > 0, ", ");
     738         [ #  # ]:          0 :             if (append_ast_constant(writer, PyTuple_GET_ITEM(constant, i)) < 0) {
     739                 :          0 :                 return -1;
     740                 :            :             }
     741                 :            :         }
     742                 :            : 
     743   [ #  #  #  # ]:          0 :         APPEND_STR_IF(elem_count == 1, ",");
     744         [ #  # ]:          0 :         APPEND_STR(")");
     745                 :          0 :         return 0;
     746                 :            :     }
     747                 :          0 :     return append_repr(writer, constant);
     748                 :            : }
     749                 :            : 
     750                 :            : static int
     751                 :          0 : append_ast_attribute(_PyUnicodeWriter *writer, expr_ty e)
     752                 :            : {
     753                 :            :     const char *period;
     754                 :          0 :     expr_ty v = e->v.Attribute.value;
     755         [ #  # ]:          0 :     APPEND_EXPR(v, PR_ATOM);
     756                 :            : 
     757                 :            :     /* Special case: integers require a space for attribute access to be
     758                 :            :        unambiguous. */
     759   [ #  #  #  # ]:          0 :     if (v->kind == Constant_kind && PyLong_CheckExact(v->v.Constant.value)) {
     760                 :          0 :         period = " .";
     761                 :            :     }
     762                 :            :     else {
     763                 :          0 :         period = ".";
     764                 :            :     }
     765         [ #  # ]:          0 :     APPEND_STR(period);
     766                 :            : 
     767                 :          0 :     return _PyUnicodeWriter_WriteStr(writer, e->v.Attribute.attr);
     768                 :            : }
     769                 :            : 
     770                 :            : static int
     771                 :          0 : append_ast_slice(_PyUnicodeWriter *writer, expr_ty e)
     772                 :            : {
     773         [ #  # ]:          0 :     if (e->v.Slice.lower) {
     774         [ #  # ]:          0 :         APPEND_EXPR(e->v.Slice.lower, PR_TEST);
     775                 :            :     }
     776                 :            : 
     777         [ #  # ]:          0 :     APPEND_STR(":");
     778                 :            : 
     779         [ #  # ]:          0 :     if (e->v.Slice.upper) {
     780         [ #  # ]:          0 :         APPEND_EXPR(e->v.Slice.upper, PR_TEST);
     781                 :            :     }
     782                 :            : 
     783         [ #  # ]:          0 :     if (e->v.Slice.step) {
     784         [ #  # ]:          0 :         APPEND_STR(":");
     785         [ #  # ]:          0 :         APPEND_EXPR(e->v.Slice.step, PR_TEST);
     786                 :            :     }
     787                 :          0 :     return 0;
     788                 :            : }
     789                 :            : 
     790                 :            : static int
     791                 :          0 : append_ast_subscript(_PyUnicodeWriter *writer, expr_ty e)
     792                 :            : {
     793         [ #  # ]:          0 :     APPEND_EXPR(e->v.Subscript.value, PR_ATOM);
     794         [ #  # ]:          0 :     APPEND_STR("[");
     795         [ #  # ]:          0 :     APPEND_EXPR(e->v.Subscript.slice, PR_TUPLE);
     796                 :          0 :     APPEND_STR_FINISH("]");
     797                 :            : }
     798                 :            : 
     799                 :            : static int
     800                 :          0 : append_ast_starred(_PyUnicodeWriter *writer, expr_ty e)
     801                 :            : {
     802         [ #  # ]:          0 :     APPEND_STR("*");
     803         [ #  # ]:          0 :     APPEND_EXPR(e->v.Starred.value, PR_EXPR);
     804                 :          0 :     return 0;
     805                 :            : }
     806                 :            : 
     807                 :            : static int
     808                 :          0 : append_ast_yield(_PyUnicodeWriter *writer, expr_ty e)
     809                 :            : {
     810         [ #  # ]:          0 :     if (!e->v.Yield.value) {
     811                 :          0 :         APPEND_STR_FINISH("(yield)");
     812                 :            :     }
     813                 :            : 
     814         [ #  # ]:          0 :     APPEND_STR("(yield ");
     815         [ #  # ]:          0 :     APPEND_EXPR(e->v.Yield.value, PR_TEST);
     816                 :          0 :     APPEND_STR_FINISH(")");
     817                 :            : }
     818                 :            : 
     819                 :            : static int
     820                 :          0 : append_ast_yield_from(_PyUnicodeWriter *writer, expr_ty e)
     821                 :            : {
     822         [ #  # ]:          0 :     APPEND_STR("(yield from ");
     823         [ #  # ]:          0 :     APPEND_EXPR(e->v.YieldFrom.value, PR_TEST);
     824                 :          0 :     APPEND_STR_FINISH(")");
     825                 :            : }
     826                 :            : 
     827                 :            : static int
     828                 :          0 : append_ast_await(_PyUnicodeWriter *writer, expr_ty e, int level)
     829                 :            : {
     830   [ #  #  #  # ]:          0 :     APPEND_STR_IF(level > PR_AWAIT, "(");
     831         [ #  # ]:          0 :     APPEND_STR("await ");
     832         [ #  # ]:          0 :     APPEND_EXPR(e->v.Await.value, PR_ATOM);
     833   [ #  #  #  # ]:          0 :     APPEND_STR_IF(level > PR_AWAIT, ")");
     834                 :          0 :     return 0;
     835                 :            : }
     836                 :            : 
     837                 :            : static int
     838                 :          0 : append_named_expr(_PyUnicodeWriter *writer, expr_ty e, int level)
     839                 :            : {
     840   [ #  #  #  # ]:          0 :     APPEND_STR_IF(level > PR_TUPLE, "(");
     841         [ #  # ]:          0 :     APPEND_EXPR(e->v.NamedExpr.target, PR_ATOM);
     842         [ #  # ]:          0 :     APPEND_STR(" := ");
     843         [ #  # ]:          0 :     APPEND_EXPR(e->v.NamedExpr.value, PR_ATOM);
     844   [ #  #  #  # ]:          0 :     APPEND_STR_IF(level > PR_TUPLE, ")");
     845                 :          0 :     return 0;
     846                 :            : }
     847                 :            : 
     848                 :            : static int
     849                 :          0 : append_ast_expr(_PyUnicodeWriter *writer, expr_ty e, int level)
     850                 :            : {
     851   [ #  #  #  #  :          0 :     switch (e->kind) {
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
     852                 :          0 :     case BoolOp_kind:
     853                 :          0 :         return append_ast_boolop(writer, e, level);
     854                 :          0 :     case BinOp_kind:
     855                 :          0 :         return append_ast_binop(writer, e, level);
     856                 :          0 :     case UnaryOp_kind:
     857                 :          0 :         return append_ast_unaryop(writer, e, level);
     858                 :          0 :     case Lambda_kind:
     859                 :          0 :         return append_ast_lambda(writer, e, level);
     860                 :          0 :     case IfExp_kind:
     861                 :          0 :         return append_ast_ifexp(writer, e, level);
     862                 :          0 :     case Dict_kind:
     863                 :          0 :         return append_ast_dict(writer, e);
     864                 :          0 :     case Set_kind:
     865                 :          0 :         return append_ast_set(writer, e);
     866                 :          0 :     case GeneratorExp_kind:
     867                 :          0 :         return append_ast_genexp(writer, e);
     868                 :          0 :     case ListComp_kind:
     869                 :          0 :         return append_ast_listcomp(writer, e);
     870                 :          0 :     case SetComp_kind:
     871                 :          0 :         return append_ast_setcomp(writer, e);
     872                 :          0 :     case DictComp_kind:
     873                 :          0 :         return append_ast_dictcomp(writer, e);
     874                 :          0 :     case Yield_kind:
     875                 :          0 :         return append_ast_yield(writer, e);
     876                 :          0 :     case YieldFrom_kind:
     877                 :          0 :         return append_ast_yield_from(writer, e);
     878                 :          0 :     case Await_kind:
     879                 :          0 :         return append_ast_await(writer, e, level);
     880                 :          0 :     case Compare_kind:
     881                 :          0 :         return append_ast_compare(writer, e, level);
     882                 :          0 :     case Call_kind:
     883                 :          0 :         return append_ast_call(writer, e);
     884                 :          0 :     case Constant_kind:
     885         [ #  # ]:          0 :         if (e->v.Constant.value == Py_Ellipsis) {
     886                 :          0 :             APPEND_STR_FINISH("...");
     887                 :            :         }
     888         [ #  # ]:          0 :         if (e->v.Constant.kind != NULL
     889         [ #  # ]:          0 :             && -1 == _PyUnicodeWriter_WriteStr(writer, e->v.Constant.kind)) {
     890                 :          0 :             return -1;
     891                 :            :         }
     892                 :          0 :         return append_ast_constant(writer, e->v.Constant.value);
     893                 :          0 :     case JoinedStr_kind:
     894                 :          0 :         return append_joinedstr(writer, e, false);
     895                 :          0 :     case FormattedValue_kind:
     896                 :          0 :         return append_formattedvalue(writer, e);
     897                 :            :     /* The following exprs can be assignment targets. */
     898                 :          0 :     case Attribute_kind:
     899                 :          0 :         return append_ast_attribute(writer, e);
     900                 :          0 :     case Subscript_kind:
     901                 :          0 :         return append_ast_subscript(writer, e);
     902                 :          0 :     case Starred_kind:
     903                 :          0 :         return append_ast_starred(writer, e);
     904                 :          0 :     case Slice_kind:
     905                 :          0 :         return append_ast_slice(writer, e);
     906                 :          0 :     case Name_kind:
     907                 :          0 :         return _PyUnicodeWriter_WriteStr(writer, e->v.Name.id);
     908                 :          0 :     case List_kind:
     909                 :          0 :         return append_ast_list(writer, e);
     910                 :          0 :     case Tuple_kind:
     911                 :          0 :         return append_ast_tuple(writer, e, level);
     912                 :          0 :     case NamedExpr_kind:
     913                 :          0 :         return append_named_expr(writer, e, level);
     914                 :            :     // No default so compiler emits a warning for unhandled cases
     915                 :            :     }
     916                 :          0 :     PyErr_SetString(PyExc_SystemError,
     917                 :            :                     "unknown expression kind");
     918                 :          0 :     return -1;
     919                 :            : }
     920                 :            : 
     921                 :            : static int
     922                 :          0 : maybe_init_static_strings(void)
     923                 :            : {
     924                 :          0 :     PyInterpreterState *interp = _PyInterpreterState_GET();
     925         [ #  # ]:          0 :     if (_str_replace_inf(interp) == NULL) {
     926                 :          0 :         PyObject *tmp = PyUnicode_FromFormat("1e%d", 1 + DBL_MAX_10_EXP);
     927         [ #  # ]:          0 :         if (tmp == NULL) {
     928                 :          0 :             return -1;
     929                 :            :         }
     930                 :          0 :         _str_replace_inf(interp) = tmp;
     931                 :            :     }
     932                 :          0 :     return 0;
     933                 :            : }
     934                 :            : 
     935                 :            : static PyObject *
     936                 :          0 : expr_as_unicode(expr_ty e, int level)
     937                 :            : {
     938                 :            :     _PyUnicodeWriter writer;
     939                 :          0 :     _PyUnicodeWriter_Init(&writer);
     940                 :          0 :     writer.min_length = 256;
     941                 :          0 :     writer.overallocate = 1;
     942   [ #  #  #  # ]:          0 :     if (-1 == maybe_init_static_strings() ||
     943                 :          0 :         -1 == append_ast_expr(&writer, e, level))
     944                 :            :     {
     945                 :          0 :         _PyUnicodeWriter_Dealloc(&writer);
     946                 :          0 :         return NULL;
     947                 :            :     }
     948                 :          0 :     return _PyUnicodeWriter_Finish(&writer);
     949                 :            : }
     950                 :            : 
     951                 :            : PyObject *
     952                 :          0 : _PyAST_ExprAsUnicode(expr_ty e)
     953                 :            : {
     954                 :          0 :     return expr_as_unicode(e, PR_TEST);
     955                 :            : }

Generated by: LCOV version 1.14