LCOV - code coverage report
Current view: top level - Parser - action_helpers.c (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 347 647 53.6 %
Date: 2023-03-20 08:15:36 Functions: 43 62 69.4 %
Branches: 175 427 41.0 %

           Branch data     Line data    Source code
       1                 :            : #include <Python.h>
       2                 :            : 
       3                 :            : #include "pegen.h"
       4                 :            : #include "string_parser.h"
       5                 :            : #include "pycore_runtime.h"         // _PyRuntime
       6                 :            : 
       7                 :            : void *
       8                 :      22600 : _PyPegen_dummy_name(Parser *p, ...)
       9                 :            : {
      10                 :      22600 :     return &_PyRuntime.parser.dummy_name;
      11                 :            : }
      12                 :            : 
      13                 :            : /* Creates a single-element asdl_seq* that contains a */
      14                 :            : asdl_seq *
      15                 :      59199 : _PyPegen_singleton_seq(Parser *p, void *a)
      16                 :            : {
      17                 :            :     assert(a != NULL);
      18                 :      59199 :     asdl_seq *seq = (asdl_seq*)_Py_asdl_generic_seq_new(1, p->arena);
      19         [ -  + ]:      59199 :     if (!seq) {
      20                 :          0 :         return NULL;
      21                 :            :     }
      22                 :      59199 :     asdl_seq_SET_UNTYPED(seq, 0, a);
      23                 :      59199 :     return seq;
      24                 :            : }
      25                 :            : 
      26                 :            : /* Creates a copy of seq and prepends a to it */
      27                 :            : asdl_seq *
      28                 :      42584 : _PyPegen_seq_insert_in_front(Parser *p, void *a, asdl_seq *seq)
      29                 :            : {
      30                 :            :     assert(a != NULL);
      31         [ +  + ]:      42584 :     if (!seq) {
      32                 :        613 :         return _PyPegen_singleton_seq(p, a);
      33                 :            :     }
      34                 :            : 
      35         [ +  - ]:      41971 :     asdl_seq *new_seq = (asdl_seq*)_Py_asdl_generic_seq_new(asdl_seq_LEN(seq) + 1, p->arena);
      36         [ -  + ]:      41971 :     if (!new_seq) {
      37                 :          0 :         return NULL;
      38                 :            :     }
      39                 :            : 
      40                 :      41971 :     asdl_seq_SET_UNTYPED(new_seq, 0, a);
      41   [ +  -  +  + ]:     492058 :     for (Py_ssize_t i = 1, l = asdl_seq_LEN(new_seq); i < l; i++) {
      42                 :     450087 :         asdl_seq_SET_UNTYPED(new_seq, i, asdl_seq_GET_UNTYPED(seq, i - 1));
      43                 :            :     }
      44                 :      41971 :     return new_seq;
      45                 :            : }
      46                 :            : 
      47                 :            : /* Creates a copy of seq and appends a to it */
      48                 :            : asdl_seq *
      49                 :          0 : _PyPegen_seq_append_to_end(Parser *p, asdl_seq *seq, void *a)
      50                 :            : {
      51                 :            :     assert(a != NULL);
      52         [ #  # ]:          0 :     if (!seq) {
      53                 :          0 :         return _PyPegen_singleton_seq(p, a);
      54                 :            :     }
      55                 :            : 
      56         [ #  # ]:          0 :     asdl_seq *new_seq = (asdl_seq*)_Py_asdl_generic_seq_new(asdl_seq_LEN(seq) + 1, p->arena);
      57         [ #  # ]:          0 :     if (!new_seq) {
      58                 :          0 :         return NULL;
      59                 :            :     }
      60                 :            : 
      61   [ #  #  #  # ]:          0 :     for (Py_ssize_t i = 0, l = asdl_seq_LEN(new_seq); i + 1 < l; i++) {
      62                 :          0 :         asdl_seq_SET_UNTYPED(new_seq, i, asdl_seq_GET_UNTYPED(seq, i));
      63                 :            :     }
      64         [ #  # ]:          0 :     asdl_seq_SET_UNTYPED(new_seq, asdl_seq_LEN(new_seq) - 1, a);
      65                 :          0 :     return new_seq;
      66                 :            : }
      67                 :            : 
      68                 :            : static Py_ssize_t
      69                 :      22976 : _get_flattened_seq_size(asdl_seq *seqs)
      70                 :            : {
      71                 :      22976 :     Py_ssize_t size = 0;
      72   [ +  -  +  + ]:      80325 :     for (Py_ssize_t i = 0, l = asdl_seq_LEN(seqs); i < l; i++) {
      73                 :      57349 :         asdl_seq *inner_seq = asdl_seq_GET_UNTYPED(seqs, i);
      74         [ +  - ]:      57349 :         size += asdl_seq_LEN(inner_seq);
      75                 :            :     }
      76                 :      22976 :     return size;
      77                 :            : }
      78                 :            : 
      79                 :            : /* Flattens an asdl_seq* of asdl_seq*s */
      80                 :            : asdl_seq *
      81                 :      22976 : _PyPegen_seq_flatten(Parser *p, asdl_seq *seqs)
      82                 :            : {
      83                 :      22976 :     Py_ssize_t flattened_seq_size = _get_flattened_seq_size(seqs);
      84                 :            :     assert(flattened_seq_size > 0);
      85                 :            : 
      86                 :      22976 :     asdl_seq *flattened_seq = (asdl_seq*)_Py_asdl_generic_seq_new(flattened_seq_size, p->arena);
      87         [ -  + ]:      22976 :     if (!flattened_seq) {
      88                 :          0 :         return NULL;
      89                 :            :     }
      90                 :            : 
      91                 :      22976 :     int flattened_seq_idx = 0;
      92   [ +  -  +  + ]:      80325 :     for (Py_ssize_t i = 0, l = asdl_seq_LEN(seqs); i < l; i++) {
      93                 :      57349 :         asdl_seq *inner_seq = asdl_seq_GET_UNTYPED(seqs, i);
      94   [ +  -  +  + ]:     114711 :         for (Py_ssize_t j = 0, li = asdl_seq_LEN(inner_seq); j < li; j++) {
      95                 :      57362 :             asdl_seq_SET_UNTYPED(flattened_seq, flattened_seq_idx++, asdl_seq_GET_UNTYPED(inner_seq, j));
      96                 :            :         }
      97                 :            :     }
      98                 :            :     assert(flattened_seq_idx == flattened_seq_size);
      99                 :            : 
     100                 :      22976 :     return flattened_seq;
     101                 :            : }
     102                 :            : 
     103                 :            : void *
     104                 :          0 : _PyPegen_seq_last_item(asdl_seq *seq)
     105                 :            : {
     106         [ #  # ]:          0 :     Py_ssize_t len = asdl_seq_LEN(seq);
     107                 :          0 :     return asdl_seq_GET_UNTYPED(seq, len - 1);
     108                 :            : }
     109                 :            : 
     110                 :            : void *
     111                 :          0 : _PyPegen_seq_first_item(asdl_seq *seq)
     112                 :            : {
     113                 :          0 :     return asdl_seq_GET_UNTYPED(seq, 0);
     114                 :            : }
     115                 :            : 
     116                 :            : /* Creates a new name of the form <first_name>.<second_name> */
     117                 :            : expr_ty
     118                 :         98 : _PyPegen_join_names_with_dot(Parser *p, expr_ty first_name, expr_ty second_name)
     119                 :            : {
     120                 :            :     assert(first_name != NULL && second_name != NULL);
     121                 :         98 :     PyObject *first_identifier = first_name->v.Name.id;
     122                 :         98 :     PyObject *second_identifier = second_name->v.Name.id;
     123                 :            : 
     124         [ -  + ]:         98 :     if (PyUnicode_READY(first_identifier) == -1) {
     125                 :          0 :         return NULL;
     126                 :            :     }
     127         [ -  + ]:         98 :     if (PyUnicode_READY(second_identifier) == -1) {
     128                 :          0 :         return NULL;
     129                 :            :     }
     130                 :         98 :     const char *first_str = PyUnicode_AsUTF8(first_identifier);
     131         [ -  + ]:         98 :     if (!first_str) {
     132                 :          0 :         return NULL;
     133                 :            :     }
     134                 :         98 :     const char *second_str = PyUnicode_AsUTF8(second_identifier);
     135         [ -  + ]:         98 :     if (!second_str) {
     136                 :          0 :         return NULL;
     137                 :            :     }
     138                 :         98 :     Py_ssize_t len = strlen(first_str) + strlen(second_str) + 1;  // +1 for the dot
     139                 :            : 
     140                 :         98 :     PyObject *str = PyBytes_FromStringAndSize(NULL, len);
     141         [ -  + ]:         98 :     if (!str) {
     142                 :          0 :         return NULL;
     143                 :            :     }
     144                 :            : 
     145                 :         98 :     char *s = PyBytes_AS_STRING(str);
     146         [ -  + ]:         98 :     if (!s) {
     147                 :          0 :         return NULL;
     148                 :            :     }
     149                 :            : 
     150                 :         98 :     strcpy(s, first_str);
     151                 :         98 :     s += strlen(first_str);
     152                 :         98 :     *s++ = '.';
     153                 :         98 :     strcpy(s, second_str);
     154                 :         98 :     s += strlen(second_str);
     155                 :         98 :     *s = '\0';
     156                 :            : 
     157                 :         98 :     PyObject *uni = PyUnicode_DecodeUTF8(PyBytes_AS_STRING(str), PyBytes_GET_SIZE(str), NULL);
     158                 :         98 :     Py_DECREF(str);
     159         [ -  + ]:         98 :     if (!uni) {
     160                 :          0 :         return NULL;
     161                 :            :     }
     162                 :         98 :     PyUnicode_InternInPlace(&uni);
     163         [ -  + ]:         98 :     if (_PyArena_AddPyObject(p->arena, uni) < 0) {
     164                 :          0 :         Py_DECREF(uni);
     165                 :          0 :         return NULL;
     166                 :            :     }
     167                 :            : 
     168                 :         98 :     return _PyAST_Name(uni, Load, EXTRA_EXPR(first_name, second_name));
     169                 :            : }
     170                 :            : 
     171                 :            : /* Counts the total number of dots in seq's tokens */
     172                 :            : int
     173                 :        524 : _PyPegen_seq_count_dots(asdl_seq *seq)
     174                 :            : {
     175                 :        524 :     int number_of_dots = 0;
     176   [ +  -  +  + ]:        696 :     for (Py_ssize_t i = 0, l = asdl_seq_LEN(seq); i < l; i++) {
     177                 :        172 :         Token *current_expr = asdl_seq_GET_UNTYPED(seq, i);
     178      [ -  +  - ]:        172 :         switch (current_expr->type) {
     179                 :          0 :             case ELLIPSIS:
     180                 :          0 :                 number_of_dots += 3;
     181                 :          0 :                 break;
     182                 :        172 :             case DOT:
     183                 :        172 :                 number_of_dots += 1;
     184                 :        172 :                 break;
     185                 :          0 :             default:
     186                 :          0 :                 Py_UNREACHABLE();
     187                 :            :         }
     188                 :            :     }
     189                 :            : 
     190                 :        524 :     return number_of_dots;
     191                 :            : }
     192                 :            : 
     193                 :            : /* Creates an alias with '*' as the identifier name */
     194                 :            : alias_ty
     195                 :         48 : _PyPegen_alias_for_star(Parser *p, int lineno, int col_offset, int end_lineno,
     196                 :            :                         int end_col_offset, PyArena *arena) {
     197                 :         48 :     PyObject *str = PyUnicode_InternFromString("*");
     198         [ -  + ]:         48 :     if (!str) {
     199                 :          0 :         return NULL;
     200                 :            :     }
     201         [ -  + ]:         48 :     if (_PyArena_AddPyObject(p->arena, str) < 0) {
     202                 :          0 :         Py_DECREF(str);
     203                 :          0 :         return NULL;
     204                 :            :     }
     205                 :         48 :     return _PyAST_alias(str, NULL, lineno, col_offset, end_lineno, end_col_offset, arena);
     206                 :            : }
     207                 :            : 
     208                 :            : /* Creates a new asdl_seq* with the identifiers of all the names in seq */
     209                 :            : asdl_identifier_seq *
     210                 :         87 : _PyPegen_map_names_to_ids(Parser *p, asdl_expr_seq *seq)
     211                 :            : {
     212         [ +  - ]:         87 :     Py_ssize_t len = asdl_seq_LEN(seq);
     213                 :            :     assert(len > 0);
     214                 :            : 
     215                 :         87 :     asdl_identifier_seq *new_seq = _Py_asdl_identifier_seq_new(len, p->arena);
     216         [ -  + ]:         87 :     if (!new_seq) {
     217                 :          0 :         return NULL;
     218                 :            :     }
     219         [ +  + ]:        195 :     for (Py_ssize_t i = 0; i < len; i++) {
     220                 :        108 :         expr_ty e = asdl_seq_GET(seq, i);
     221                 :        108 :         asdl_seq_SET(new_seq, i, e->v.Name.id);
     222                 :            :     }
     223                 :         87 :     return new_seq;
     224                 :            : }
     225                 :            : 
     226                 :            : /* Constructs a CmpopExprPair */
     227                 :            : CmpopExprPair *
     228                 :       6253 : _PyPegen_cmpop_expr_pair(Parser *p, cmpop_ty cmpop, expr_ty expr)
     229                 :            : {
     230                 :            :     assert(expr != NULL);
     231                 :       6253 :     CmpopExprPair *a = _PyArena_Malloc(p->arena, sizeof(CmpopExprPair));
     232         [ -  + ]:       6253 :     if (!a) {
     233                 :          0 :         return NULL;
     234                 :            :     }
     235                 :       6253 :     a->cmpop = cmpop;
     236                 :       6253 :     a->expr = expr;
     237                 :       6253 :     return a;
     238                 :            : }
     239                 :            : 
     240                 :            : asdl_int_seq *
     241                 :       6203 : _PyPegen_get_cmpops(Parser *p, asdl_seq *seq)
     242                 :            : {
     243         [ +  - ]:       6203 :     Py_ssize_t len = asdl_seq_LEN(seq);
     244                 :            :     assert(len > 0);
     245                 :            : 
     246                 :       6203 :     asdl_int_seq *new_seq = _Py_asdl_int_seq_new(len, p->arena);
     247         [ -  + ]:       6203 :     if (!new_seq) {
     248                 :          0 :         return NULL;
     249                 :            :     }
     250         [ +  + ]:      12456 :     for (Py_ssize_t i = 0; i < len; i++) {
     251                 :       6253 :         CmpopExprPair *pair = asdl_seq_GET_UNTYPED(seq, i);
     252                 :       6253 :         asdl_seq_SET(new_seq, i, pair->cmpop);
     253                 :            :     }
     254                 :       6203 :     return new_seq;
     255                 :            : }
     256                 :            : 
     257                 :            : asdl_expr_seq *
     258                 :       6203 : _PyPegen_get_exprs(Parser *p, asdl_seq *seq)
     259                 :            : {
     260         [ +  - ]:       6203 :     Py_ssize_t len = asdl_seq_LEN(seq);
     261                 :            :     assert(len > 0);
     262                 :            : 
     263                 :       6203 :     asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(len, p->arena);
     264         [ -  + ]:       6203 :     if (!new_seq) {
     265                 :          0 :         return NULL;
     266                 :            :     }
     267         [ +  + ]:      12456 :     for (Py_ssize_t i = 0; i < len; i++) {
     268                 :       6253 :         CmpopExprPair *pair = asdl_seq_GET_UNTYPED(seq, i);
     269                 :       6253 :         asdl_seq_SET(new_seq, i, pair->expr);
     270                 :            :     }
     271                 :       6203 :     return new_seq;
     272                 :            : }
     273                 :            : 
     274                 :            : /* Creates an asdl_seq* where all the elements have been changed to have ctx as context */
     275                 :            : static asdl_expr_seq *
     276                 :          0 : _set_seq_context(Parser *p, asdl_expr_seq *seq, expr_context_ty ctx)
     277                 :            : {
     278         [ #  # ]:          0 :     Py_ssize_t len = asdl_seq_LEN(seq);
     279         [ #  # ]:          0 :     if (len == 0) {
     280                 :          0 :         return NULL;
     281                 :            :     }
     282                 :            : 
     283                 :          0 :     asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(len, p->arena);
     284         [ #  # ]:          0 :     if (!new_seq) {
     285                 :          0 :         return NULL;
     286                 :            :     }
     287         [ #  # ]:          0 :     for (Py_ssize_t i = 0; i < len; i++) {
     288                 :          0 :         expr_ty e = asdl_seq_GET(seq, i);
     289                 :          0 :         asdl_seq_SET(new_seq, i, _PyPegen_set_expr_context(p, e, ctx));
     290                 :            :     }
     291                 :          0 :     return new_seq;
     292                 :            : }
     293                 :            : 
     294                 :            : static expr_ty
     295                 :      42070 : _set_name_context(Parser *p, expr_ty e, expr_context_ty ctx)
     296                 :            : {
     297                 :      42070 :     return _PyAST_Name(e->v.Name.id, ctx, EXTRA_EXPR(e, e));
     298                 :            : }
     299                 :            : 
     300                 :            : static expr_ty
     301                 :          0 : _set_tuple_context(Parser *p, expr_ty e, expr_context_ty ctx)
     302                 :            : {
     303                 :          0 :     return _PyAST_Tuple(
     304                 :            :             _set_seq_context(p, e->v.Tuple.elts, ctx),
     305                 :            :             ctx,
     306                 :            :             EXTRA_EXPR(e, e));
     307                 :            : }
     308                 :            : 
     309                 :            : static expr_ty
     310                 :          0 : _set_list_context(Parser *p, expr_ty e, expr_context_ty ctx)
     311                 :            : {
     312                 :          0 :     return _PyAST_List(
     313                 :            :             _set_seq_context(p, e->v.List.elts, ctx),
     314                 :            :             ctx,
     315                 :            :             EXTRA_EXPR(e, e));
     316                 :            : }
     317                 :            : 
     318                 :            : static expr_ty
     319                 :          3 : _set_subscript_context(Parser *p, expr_ty e, expr_context_ty ctx)
     320                 :            : {
     321                 :          3 :     return _PyAST_Subscript(e->v.Subscript.value, e->v.Subscript.slice,
     322                 :            :                             ctx, EXTRA_EXPR(e, e));
     323                 :            : }
     324                 :            : 
     325                 :            : static expr_ty
     326                 :          1 : _set_attribute_context(Parser *p, expr_ty e, expr_context_ty ctx)
     327                 :            : {
     328                 :          1 :     return _PyAST_Attribute(e->v.Attribute.value, e->v.Attribute.attr,
     329                 :            :                             ctx, EXTRA_EXPR(e, e));
     330                 :            : }
     331                 :            : 
     332                 :            : static expr_ty
     333                 :          0 : _set_starred_context(Parser *p, expr_ty e, expr_context_ty ctx)
     334                 :            : {
     335                 :          0 :     return _PyAST_Starred(_PyPegen_set_expr_context(p, e->v.Starred.value, ctx),
     336                 :            :                           ctx, EXTRA_EXPR(e, e));
     337                 :            : }
     338                 :            : 
     339                 :            : /* Creates an `expr_ty` equivalent to `expr` but with `ctx` as context */
     340                 :            : expr_ty
     341                 :      42074 : _PyPegen_set_expr_context(Parser *p, expr_ty expr, expr_context_ty ctx)
     342                 :            : {
     343                 :            :     assert(expr != NULL);
     344                 :            : 
     345                 :      42074 :     expr_ty new = NULL;
     346   [ +  -  -  +  :      42074 :     switch (expr->kind) {
                +  -  - ]
     347                 :      42070 :         case Name_kind:
     348                 :      42070 :             new = _set_name_context(p, expr, ctx);
     349                 :      42070 :             break;
     350                 :          0 :         case Tuple_kind:
     351                 :          0 :             new = _set_tuple_context(p, expr, ctx);
     352                 :          0 :             break;
     353                 :          0 :         case List_kind:
     354                 :          0 :             new = _set_list_context(p, expr, ctx);
     355                 :          0 :             break;
     356                 :          3 :         case Subscript_kind:
     357                 :          3 :             new = _set_subscript_context(p, expr, ctx);
     358                 :          3 :             break;
     359                 :          1 :         case Attribute_kind:
     360                 :          1 :             new = _set_attribute_context(p, expr, ctx);
     361                 :          1 :             break;
     362                 :          0 :         case Starred_kind:
     363                 :          0 :             new = _set_starred_context(p, expr, ctx);
     364                 :          0 :             break;
     365                 :          0 :         default:
     366                 :          0 :             new = expr;
     367                 :            :     }
     368                 :      42074 :     return new;
     369                 :            : }
     370                 :            : 
     371                 :            : /* Constructs a KeyValuePair that is used when parsing a dict's key value pairs */
     372                 :            : KeyValuePair *
     373                 :       8665 : _PyPegen_key_value_pair(Parser *p, expr_ty key, expr_ty value)
     374                 :            : {
     375                 :       8665 :     KeyValuePair *a = _PyArena_Malloc(p->arena, sizeof(KeyValuePair));
     376         [ -  + ]:       8665 :     if (!a) {
     377                 :          0 :         return NULL;
     378                 :            :     }
     379                 :       8665 :     a->key = key;
     380                 :       8665 :     a->value = value;
     381                 :       8665 :     return a;
     382                 :            : }
     383                 :            : 
     384                 :            : /* Extracts all keys from an asdl_seq* of KeyValuePair*'s */
     385                 :            : asdl_expr_seq *
     386                 :       1063 : _PyPegen_get_keys(Parser *p, asdl_seq *seq)
     387                 :            : {
     388         [ +  + ]:       1063 :     Py_ssize_t len = asdl_seq_LEN(seq);
     389                 :       1063 :     asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(len, p->arena);
     390         [ -  + ]:       1063 :     if (!new_seq) {
     391                 :          0 :         return NULL;
     392                 :            :     }
     393         [ +  + ]:       9536 :     for (Py_ssize_t i = 0; i < len; i++) {
     394                 :       8473 :         KeyValuePair *pair = asdl_seq_GET_UNTYPED(seq, i);
     395                 :       8473 :         asdl_seq_SET(new_seq, i, pair->key);
     396                 :            :     }
     397                 :       1063 :     return new_seq;
     398                 :            : }
     399                 :            : 
     400                 :            : /* Extracts all values from an asdl_seq* of KeyValuePair*'s */
     401                 :            : asdl_expr_seq *
     402                 :       1063 : _PyPegen_get_values(Parser *p, asdl_seq *seq)
     403                 :            : {
     404         [ +  + ]:       1063 :     Py_ssize_t len = asdl_seq_LEN(seq);
     405                 :       1063 :     asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(len, p->arena);
     406         [ -  + ]:       1063 :     if (!new_seq) {
     407                 :          0 :         return NULL;
     408                 :            :     }
     409         [ +  + ]:       9536 :     for (Py_ssize_t i = 0; i < len; i++) {
     410                 :       8473 :         KeyValuePair *pair = asdl_seq_GET_UNTYPED(seq, i);
     411                 :       8473 :         asdl_seq_SET(new_seq, i, pair->value);
     412                 :            :     }
     413                 :       1063 :     return new_seq;
     414                 :            : }
     415                 :            : 
     416                 :            : /* Constructs a KeyPatternPair that is used when parsing mapping & class patterns */
     417                 :            : KeyPatternPair *
     418                 :          0 : _PyPegen_key_pattern_pair(Parser *p, expr_ty key, pattern_ty pattern)
     419                 :            : {
     420                 :          0 :     KeyPatternPair *a = _PyArena_Malloc(p->arena, sizeof(KeyPatternPair));
     421         [ #  # ]:          0 :     if (!a) {
     422                 :          0 :         return NULL;
     423                 :            :     }
     424                 :          0 :     a->key = key;
     425                 :          0 :     a->pattern = pattern;
     426                 :          0 :     return a;
     427                 :            : }
     428                 :            : 
     429                 :            : /* Extracts all keys from an asdl_seq* of KeyPatternPair*'s */
     430                 :            : asdl_expr_seq *
     431                 :          0 : _PyPegen_get_pattern_keys(Parser *p, asdl_seq *seq)
     432                 :            : {
     433         [ #  # ]:          0 :     Py_ssize_t len = asdl_seq_LEN(seq);
     434                 :          0 :     asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(len, p->arena);
     435         [ #  # ]:          0 :     if (!new_seq) {
     436                 :          0 :         return NULL;
     437                 :            :     }
     438         [ #  # ]:          0 :     for (Py_ssize_t i = 0; i < len; i++) {
     439                 :          0 :         KeyPatternPair *pair = asdl_seq_GET_UNTYPED(seq, i);
     440                 :          0 :         asdl_seq_SET(new_seq, i, pair->key);
     441                 :            :     }
     442                 :          0 :     return new_seq;
     443                 :            : }
     444                 :            : 
     445                 :            : /* Extracts all patterns from an asdl_seq* of KeyPatternPair*'s */
     446                 :            : asdl_pattern_seq *
     447                 :          0 : _PyPegen_get_patterns(Parser *p, asdl_seq *seq)
     448                 :            : {
     449         [ #  # ]:          0 :     Py_ssize_t len = asdl_seq_LEN(seq);
     450                 :          0 :     asdl_pattern_seq *new_seq = _Py_asdl_pattern_seq_new(len, p->arena);
     451         [ #  # ]:          0 :     if (!new_seq) {
     452                 :          0 :         return NULL;
     453                 :            :     }
     454         [ #  # ]:          0 :     for (Py_ssize_t i = 0; i < len; i++) {
     455                 :          0 :         KeyPatternPair *pair = asdl_seq_GET_UNTYPED(seq, i);
     456                 :          0 :         asdl_seq_SET(new_seq, i, pair->pattern);
     457                 :            :     }
     458                 :          0 :     return new_seq;
     459                 :            : }
     460                 :            : 
     461                 :            : /* Constructs a NameDefaultPair */
     462                 :            : NameDefaultPair *
     463                 :       5845 : _PyPegen_name_default_pair(Parser *p, arg_ty arg, expr_ty value, Token *tc)
     464                 :            : {
     465                 :       5845 :     NameDefaultPair *a = _PyArena_Malloc(p->arena, sizeof(NameDefaultPair));
     466         [ -  + ]:       5845 :     if (!a) {
     467                 :          0 :         return NULL;
     468                 :            :     }
     469                 :       5845 :     a->arg = _PyPegen_add_type_comment_to_arg(p, arg, tc);
     470                 :       5845 :     a->value = value;
     471                 :       5845 :     return a;
     472                 :            : }
     473                 :            : 
     474                 :            : /* Constructs a SlashWithDefault */
     475                 :            : SlashWithDefault *
     476                 :         18 : _PyPegen_slash_with_default(Parser *p, asdl_arg_seq *plain_names, asdl_seq *names_with_defaults)
     477                 :            : {
     478                 :         18 :     SlashWithDefault *a = _PyArena_Malloc(p->arena, sizeof(SlashWithDefault));
     479         [ -  + ]:         18 :     if (!a) {
     480                 :          0 :         return NULL;
     481                 :            :     }
     482                 :         18 :     a->plain_names = plain_names;
     483                 :         18 :     a->names_with_defaults = names_with_defaults;
     484                 :         18 :     return a;
     485                 :            : }
     486                 :            : 
     487                 :            : /* Constructs a StarEtc */
     488                 :            : StarEtc *
     489                 :        566 : _PyPegen_star_etc(Parser *p, arg_ty vararg, asdl_seq *kwonlyargs, arg_ty kwarg)
     490                 :            : {
     491                 :        566 :     StarEtc *a = _PyArena_Malloc(p->arena, sizeof(StarEtc));
     492         [ -  + ]:        566 :     if (!a) {
     493                 :          0 :         return NULL;
     494                 :            :     }
     495                 :        566 :     a->vararg = vararg;
     496                 :        566 :     a->kwonlyargs = kwonlyargs;
     497                 :        566 :     a->kwarg = kwarg;
     498                 :        566 :     return a;
     499                 :            : }
     500                 :            : 
     501                 :            : asdl_seq *
     502                 :       6089 : _PyPegen_join_sequences(Parser *p, asdl_seq *a, asdl_seq *b)
     503                 :            : {
     504         [ +  - ]:       6089 :     Py_ssize_t first_len = asdl_seq_LEN(a);
     505         [ +  - ]:       6089 :     Py_ssize_t second_len = asdl_seq_LEN(b);
     506                 :       6089 :     asdl_seq *new_seq = (asdl_seq*)_Py_asdl_generic_seq_new(first_len + second_len, p->arena);
     507         [ -  + ]:       6089 :     if (!new_seq) {
     508                 :          0 :         return NULL;
     509                 :            :     }
     510                 :            : 
     511                 :       6089 :     int k = 0;
     512         [ +  + ]:      16709 :     for (Py_ssize_t i = 0; i < first_len; i++) {
     513                 :      10620 :         asdl_seq_SET_UNTYPED(new_seq, k++, asdl_seq_GET_UNTYPED(a, i));
     514                 :            :     }
     515         [ +  + ]:       7706 :     for (Py_ssize_t i = 0; i < second_len; i++) {
     516                 :       1617 :         asdl_seq_SET_UNTYPED(new_seq, k++, asdl_seq_GET_UNTYPED(b, i));
     517                 :            :     }
     518                 :            : 
     519                 :       6089 :     return new_seq;
     520                 :            : }
     521                 :            : 
     522                 :            : static asdl_arg_seq*
     523                 :       6666 : _get_names(Parser *p, asdl_seq *names_with_defaults)
     524                 :            : {
     525         [ +  - ]:       6666 :     Py_ssize_t len = asdl_seq_LEN(names_with_defaults);
     526                 :       6666 :     asdl_arg_seq *seq = _Py_asdl_arg_seq_new(len, p->arena);
     527         [ -  + ]:       6666 :     if (!seq) {
     528                 :          0 :         return NULL;
     529                 :            :     }
     530         [ +  + ]:       9015 :     for (Py_ssize_t i = 0; i < len; i++) {
     531                 :       2349 :         NameDefaultPair *pair = asdl_seq_GET_UNTYPED(names_with_defaults, i);
     532                 :       2349 :         asdl_seq_SET(seq, i, pair->arg);
     533                 :            :     }
     534                 :       6666 :     return seq;
     535                 :            : }
     536                 :            : 
     537                 :            : static asdl_expr_seq *
     538                 :       6666 : _get_defaults(Parser *p, asdl_seq *names_with_defaults)
     539                 :            : {
     540         [ +  - ]:       6666 :     Py_ssize_t len = asdl_seq_LEN(names_with_defaults);
     541                 :       6666 :     asdl_expr_seq *seq = _Py_asdl_expr_seq_new(len, p->arena);
     542         [ -  + ]:       6666 :     if (!seq) {
     543                 :          0 :         return NULL;
     544                 :            :     }
     545         [ +  + ]:       9015 :     for (Py_ssize_t i = 0; i < len; i++) {
     546                 :       2349 :         NameDefaultPair *pair = asdl_seq_GET_UNTYPED(names_with_defaults, i);
     547                 :       2349 :         asdl_seq_SET(seq, i, pair->value);
     548                 :            :     }
     549                 :       6666 :     return seq;
     550                 :            : }
     551                 :            : 
     552                 :            : static int
     553                 :       6223 : _make_posonlyargs(Parser *p,
     554                 :            :                   asdl_arg_seq *slash_without_default,
     555                 :            :                   SlashWithDefault *slash_with_default,
     556                 :            :                   asdl_arg_seq **posonlyargs) {
     557         [ +  + ]:       6223 :     if (slash_without_default != NULL) {
     558                 :         47 :         *posonlyargs = slash_without_default;
     559                 :            :     }
     560         [ +  + ]:       6176 :     else if (slash_with_default != NULL) {
     561                 :            :         asdl_arg_seq *slash_with_default_names =
     562                 :         18 :                 _get_names(p, slash_with_default->names_with_defaults);
     563         [ -  + ]:         18 :         if (!slash_with_default_names) {
     564                 :          0 :             return -1;
     565                 :            :         }
     566                 :         18 :         *posonlyargs = (asdl_arg_seq*)_PyPegen_join_sequences(
     567                 :            :                 p,
     568                 :         18 :                 (asdl_seq*)slash_with_default->plain_names,
     569                 :            :                 (asdl_seq*)slash_with_default_names);
     570                 :            :     }
     571                 :            :     else {
     572                 :       6158 :         *posonlyargs = _Py_asdl_arg_seq_new(0, p->arena);
     573                 :            :     }
     574         [ -  + ]:       6223 :     return *posonlyargs == NULL ? -1 : 0;
     575                 :            : }
     576                 :            : 
     577                 :            : static int
     578                 :       6223 : _make_posargs(Parser *p,
     579                 :            :               asdl_arg_seq *plain_names,
     580                 :            :               asdl_seq *names_with_default,
     581                 :            :               asdl_arg_seq **posargs) {
     582   [ +  +  +  - ]:       6223 :     if (plain_names != NULL && names_with_default != NULL) {
     583                 :       6037 :         asdl_arg_seq *names_with_default_names = _get_names(p, names_with_default);
     584         [ -  + ]:       6037 :         if (!names_with_default_names) {
     585                 :          0 :             return -1;
     586                 :            :         }
     587                 :       6037 :         *posargs = (asdl_arg_seq*)_PyPegen_join_sequences(
     588                 :            :                 p,(asdl_seq*)plain_names, (asdl_seq*)names_with_default_names);
     589                 :            :     }
     590   [ +  -  +  + ]:        186 :     else if (plain_names == NULL && names_with_default != NULL) {
     591                 :        108 :         *posargs = _get_names(p, names_with_default);
     592                 :            :     }
     593   [ -  +  -  - ]:         78 :     else if (plain_names != NULL && names_with_default == NULL) {
     594                 :          0 :         *posargs = plain_names;
     595                 :            :     }
     596                 :            :     else {
     597                 :         78 :         *posargs = _Py_asdl_arg_seq_new(0, p->arena);
     598                 :            :     }
     599         [ -  + ]:       6223 :     return *posargs == NULL ? -1 : 0;
     600                 :            : }
     601                 :            : 
     602                 :            : static int
     603                 :       6223 : _make_posdefaults(Parser *p,
     604                 :            :                   SlashWithDefault *slash_with_default,
     605                 :            :                   asdl_seq *names_with_default,
     606                 :            :                   asdl_expr_seq **posdefaults) {
     607   [ +  +  +  - ]:       6223 :     if (slash_with_default != NULL && names_with_default != NULL) {
     608                 :            :         asdl_expr_seq *slash_with_default_values =
     609                 :         18 :                 _get_defaults(p, slash_with_default->names_with_defaults);
     610         [ -  + ]:         18 :         if (!slash_with_default_values) {
     611                 :          0 :             return -1;
     612                 :            :         }
     613                 :         18 :         asdl_expr_seq *names_with_default_values = _get_defaults(p, names_with_default);
     614         [ -  + ]:         18 :         if (!names_with_default_values) {
     615                 :          0 :             return -1;
     616                 :            :         }
     617                 :         18 :         *posdefaults = (asdl_expr_seq*)_PyPegen_join_sequences(
     618                 :            :                 p,
     619                 :            :                 (asdl_seq*)slash_with_default_values,
     620                 :            :                 (asdl_seq*)names_with_default_values);
     621                 :            :     }
     622   [ +  -  +  + ]:       6205 :     else if (slash_with_default == NULL && names_with_default != NULL) {
     623                 :       6127 :         *posdefaults = _get_defaults(p, names_with_default);
     624                 :            :     }
     625   [ -  +  -  - ]:         78 :     else if (slash_with_default != NULL && names_with_default == NULL) {
     626                 :          0 :         *posdefaults = _get_defaults(p, slash_with_default->names_with_defaults);
     627                 :            :     }
     628                 :            :     else {
     629                 :         78 :         *posdefaults = _Py_asdl_expr_seq_new(0, p->arena);
     630                 :            :     }
     631         [ -  + ]:       6223 :     return *posdefaults == NULL ? -1 : 0;
     632                 :            : }
     633                 :            : 
     634                 :            : static int
     635                 :       6223 : _make_kwargs(Parser *p, StarEtc *star_etc,
     636                 :            :              asdl_arg_seq **kwonlyargs,
     637                 :            :              asdl_expr_seq **kwdefaults) {
     638   [ +  +  +  + ]:       6223 :     if (star_etc != NULL && star_etc->kwonlyargs != NULL) {
     639                 :        503 :         *kwonlyargs = _get_names(p, star_etc->kwonlyargs);
     640                 :            :     }
     641                 :            :     else {
     642                 :       5720 :         *kwonlyargs = _Py_asdl_arg_seq_new(0, p->arena);
     643                 :            :     }
     644                 :            : 
     645         [ -  + ]:       6223 :     if (*kwonlyargs == NULL) {
     646                 :          0 :         return -1;
     647                 :            :     }
     648                 :            : 
     649   [ +  +  +  + ]:       6223 :     if (star_etc != NULL && star_etc->kwonlyargs != NULL) {
     650                 :        503 :         *kwdefaults = _get_defaults(p, star_etc->kwonlyargs);
     651                 :            :     }
     652                 :            :     else {
     653                 :       5720 :         *kwdefaults = _Py_asdl_expr_seq_new(0, p->arena);
     654                 :            :     }
     655                 :            : 
     656         [ -  + ]:       6223 :     if (*kwdefaults == NULL) {
     657                 :          0 :         return -1;
     658                 :            :     }
     659                 :            : 
     660                 :       6223 :     return 0;
     661                 :            : }
     662                 :            : 
     663                 :            : /* Constructs an arguments_ty object out of all the parsed constructs in the parameters rule */
     664                 :            : arguments_ty
     665                 :       6223 : _PyPegen_make_arguments(Parser *p, asdl_arg_seq *slash_without_default,
     666                 :            :                         SlashWithDefault *slash_with_default, asdl_arg_seq *plain_names,
     667                 :            :                         asdl_seq *names_with_default, StarEtc *star_etc)
     668                 :            : {
     669                 :            :     asdl_arg_seq *posonlyargs;
     670         [ -  + ]:       6223 :     if (_make_posonlyargs(p, slash_without_default, slash_with_default, &posonlyargs) == -1) {
     671                 :          0 :         return NULL;
     672                 :            :     }
     673                 :            : 
     674                 :            :     asdl_arg_seq *posargs;
     675         [ -  + ]:       6223 :     if (_make_posargs(p, plain_names, names_with_default, &posargs) == -1) {
     676                 :          0 :         return NULL;
     677                 :            :     }
     678                 :            : 
     679                 :            :     asdl_expr_seq *posdefaults;
     680         [ -  + ]:       6223 :     if (_make_posdefaults(p,slash_with_default, names_with_default, &posdefaults) == -1) {
     681                 :          0 :         return NULL;
     682                 :            :     }
     683                 :            : 
     684                 :       6223 :     arg_ty vararg = NULL;
     685   [ +  +  +  + ]:       6223 :     if (star_etc != NULL && star_etc->vararg != NULL) {
     686                 :        309 :         vararg = star_etc->vararg;
     687                 :            :     }
     688                 :            : 
     689                 :            :     asdl_arg_seq *kwonlyargs;
     690                 :            :     asdl_expr_seq *kwdefaults;
     691         [ -  + ]:       6223 :     if (_make_kwargs(p, star_etc, &kwonlyargs, &kwdefaults) == -1) {
     692                 :          0 :         return NULL;
     693                 :            :     }
     694                 :            : 
     695                 :       6223 :     arg_ty kwarg = NULL;
     696   [ +  +  +  + ]:       6223 :     if (star_etc != NULL && star_etc->kwarg != NULL) {
     697                 :        216 :         kwarg = star_etc->kwarg;
     698                 :            :     }
     699                 :            : 
     700                 :       6223 :     return _PyAST_arguments(posonlyargs, posargs, vararg, kwonlyargs,
     701                 :            :                             kwdefaults, kwarg, posdefaults, p->arena);
     702                 :            : }
     703                 :            : 
     704                 :            : 
     705                 :            : /* Constructs an empty arguments_ty object, that gets used when a function accepts no
     706                 :            :  * arguments. */
     707                 :            : arguments_ty
     708                 :        313 : _PyPegen_empty_arguments(Parser *p)
     709                 :            : {
     710                 :        313 :     asdl_arg_seq *posonlyargs = _Py_asdl_arg_seq_new(0, p->arena);
     711         [ -  + ]:        313 :     if (!posonlyargs) {
     712                 :          0 :         return NULL;
     713                 :            :     }
     714                 :        313 :     asdl_arg_seq *posargs = _Py_asdl_arg_seq_new(0, p->arena);
     715         [ -  + ]:        313 :     if (!posargs) {
     716                 :          0 :         return NULL;
     717                 :            :     }
     718                 :        313 :     asdl_expr_seq *posdefaults = _Py_asdl_expr_seq_new(0, p->arena);
     719         [ -  + ]:        313 :     if (!posdefaults) {
     720                 :          0 :         return NULL;
     721                 :            :     }
     722                 :        313 :     asdl_arg_seq *kwonlyargs = _Py_asdl_arg_seq_new(0, p->arena);
     723         [ -  + ]:        313 :     if (!kwonlyargs) {
     724                 :          0 :         return NULL;
     725                 :            :     }
     726                 :        313 :     asdl_expr_seq *kwdefaults = _Py_asdl_expr_seq_new(0, p->arena);
     727         [ -  + ]:        313 :     if (!kwdefaults) {
     728                 :          0 :         return NULL;
     729                 :            :     }
     730                 :            : 
     731                 :        313 :     return _PyAST_arguments(posonlyargs, posargs, NULL, kwonlyargs,
     732                 :            :                             kwdefaults, NULL, posdefaults, p->arena);
     733                 :            : }
     734                 :            : 
     735                 :            : /* Encapsulates the value of an operator_ty into an AugOperator struct */
     736                 :            : AugOperator *
     737                 :        715 : _PyPegen_augoperator(Parser *p, operator_ty kind)
     738                 :            : {
     739                 :        715 :     AugOperator *a = _PyArena_Malloc(p->arena, sizeof(AugOperator));
     740         [ -  + ]:        715 :     if (!a) {
     741                 :          0 :         return NULL;
     742                 :            :     }
     743                 :        715 :     a->kind = kind;
     744                 :        715 :     return a;
     745                 :            : }
     746                 :            : 
     747                 :            : /* Construct a FunctionDef equivalent to function_def, but with decorators */
     748                 :            : stmt_ty
     749                 :        573 : _PyPegen_function_def_decorators(Parser *p, asdl_expr_seq *decorators, stmt_ty function_def)
     750                 :            : {
     751                 :            :     assert(function_def != NULL);
     752         [ +  + ]:        573 :     if (function_def->kind == AsyncFunctionDef_kind) {
     753                 :          8 :         return _PyAST_AsyncFunctionDef(
     754                 :            :             function_def->v.FunctionDef.name, function_def->v.FunctionDef.args,
     755                 :            :             function_def->v.FunctionDef.body, decorators, function_def->v.FunctionDef.returns,
     756                 :            :             function_def->v.FunctionDef.type_comment, function_def->lineno,
     757                 :            :             function_def->col_offset, function_def->end_lineno, function_def->end_col_offset,
     758                 :            :             p->arena);
     759                 :            :     }
     760                 :            : 
     761                 :        565 :     return _PyAST_FunctionDef(
     762                 :            :         function_def->v.FunctionDef.name, function_def->v.FunctionDef.args,
     763                 :            :         function_def->v.FunctionDef.body, decorators,
     764                 :            :         function_def->v.FunctionDef.returns,
     765                 :            :         function_def->v.FunctionDef.type_comment, function_def->lineno,
     766                 :            :         function_def->col_offset, function_def->end_lineno,
     767                 :            :         function_def->end_col_offset, p->arena);
     768                 :            : }
     769                 :            : 
     770                 :            : /* Construct a ClassDef equivalent to class_def, but with decorators */
     771                 :            : stmt_ty
     772                 :         17 : _PyPegen_class_def_decorators(Parser *p, asdl_expr_seq *decorators, stmt_ty class_def)
     773                 :            : {
     774                 :            :     assert(class_def != NULL);
     775                 :         17 :     return _PyAST_ClassDef(
     776                 :            :         class_def->v.ClassDef.name, class_def->v.ClassDef.bases,
     777                 :            :         class_def->v.ClassDef.keywords, class_def->v.ClassDef.body, decorators,
     778                 :            :         class_def->lineno, class_def->col_offset, class_def->end_lineno,
     779                 :            :         class_def->end_col_offset, p->arena);
     780                 :            : }
     781                 :            : 
     782                 :            : /* Construct a KeywordOrStarred */
     783                 :            : KeywordOrStarred *
     784                 :       4155 : _PyPegen_keyword_or_starred(Parser *p, void *element, int is_keyword)
     785                 :            : {
     786                 :       4155 :     KeywordOrStarred *a = _PyArena_Malloc(p->arena, sizeof(KeywordOrStarred));
     787         [ -  + ]:       4155 :     if (!a) {
     788                 :          0 :         return NULL;
     789                 :            :     }
     790                 :       4155 :     a->element = element;
     791                 :       4155 :     a->is_keyword = is_keyword;
     792                 :       4155 :     return a;
     793                 :            : }
     794                 :            : 
     795                 :            : /* Get the number of starred expressions in an asdl_seq* of KeywordOrStarred*s */
     796                 :            : static int
     797                 :       2762 : _seq_number_of_starred_exprs(asdl_seq *seq)
     798                 :            : {
     799                 :       2762 :     int n = 0;
     800   [ +  -  +  + ]:       7132 :     for (Py_ssize_t i = 0, l = asdl_seq_LEN(seq); i < l; i++) {
     801                 :       4370 :         KeywordOrStarred *k = asdl_seq_GET_UNTYPED(seq, i);
     802         [ -  + ]:       4370 :         if (!k->is_keyword) {
     803                 :          0 :             n++;
     804                 :            :         }
     805                 :            :     }
     806                 :       2762 :     return n;
     807                 :            : }
     808                 :            : 
     809                 :            : /* Extract the starred expressions of an asdl_seq* of KeywordOrStarred*s */
     810                 :            : asdl_expr_seq *
     811                 :       1381 : _PyPegen_seq_extract_starred_exprs(Parser *p, asdl_seq *kwargs)
     812                 :            : {
     813                 :       1381 :     int new_len = _seq_number_of_starred_exprs(kwargs);
     814         [ +  - ]:       1381 :     if (new_len == 0) {
     815                 :       1381 :         return NULL;
     816                 :            :     }
     817                 :          0 :     asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(new_len, p->arena);
     818         [ #  # ]:          0 :     if (!new_seq) {
     819                 :          0 :         return NULL;
     820                 :            :     }
     821                 :            : 
     822                 :          0 :     int idx = 0;
     823   [ #  #  #  # ]:          0 :     for (Py_ssize_t i = 0, len = asdl_seq_LEN(kwargs); i < len; i++) {
     824                 :          0 :         KeywordOrStarred *k = asdl_seq_GET_UNTYPED(kwargs, i);
     825         [ #  # ]:          0 :         if (!k->is_keyword) {
     826                 :          0 :             asdl_seq_SET(new_seq, idx++, k->element);
     827                 :            :         }
     828                 :            :     }
     829                 :          0 :     return new_seq;
     830                 :            : }
     831                 :            : 
     832                 :            : /* Return a new asdl_seq* with only the keywords in kwargs */
     833                 :            : asdl_keyword_seq*
     834                 :       1381 : _PyPegen_seq_delete_starred_exprs(Parser *p, asdl_seq *kwargs)
     835                 :            : {
     836         [ +  - ]:       1381 :     Py_ssize_t len = asdl_seq_LEN(kwargs);
     837                 :       1381 :     Py_ssize_t new_len = len - _seq_number_of_starred_exprs(kwargs);
     838         [ -  + ]:       1381 :     if (new_len == 0) {
     839                 :          0 :         return NULL;
     840                 :            :     }
     841                 :       1381 :     asdl_keyword_seq *new_seq = _Py_asdl_keyword_seq_new(new_len, p->arena);
     842         [ -  + ]:       1381 :     if (!new_seq) {
     843                 :          0 :         return NULL;
     844                 :            :     }
     845                 :            : 
     846                 :       1381 :     int idx = 0;
     847         [ +  + ]:       3566 :     for (Py_ssize_t i = 0; i < len; i++) {
     848                 :       2185 :         KeywordOrStarred *k = asdl_seq_GET_UNTYPED(kwargs, i);
     849         [ +  - ]:       2185 :         if (k->is_keyword) {
     850                 :       2185 :             asdl_seq_SET(new_seq, idx++, k->element);
     851                 :            :         }
     852                 :            :     }
     853                 :       1381 :     return new_seq;
     854                 :            : }
     855                 :            : 
     856                 :            : expr_ty
     857                 :      21291 : _PyPegen_concatenate_strings(Parser *p, asdl_seq *strings)
     858                 :            : {
     859         [ +  - ]:      21291 :     Py_ssize_t len = asdl_seq_LEN(strings);
     860                 :            :     assert(len > 0);
     861                 :            : 
     862                 :      21291 :     Token *first = asdl_seq_GET_UNTYPED(strings, 0);
     863                 :      21291 :     Token *last = asdl_seq_GET_UNTYPED(strings, len - 1);
     864                 :            : 
     865                 :      21291 :     int bytesmode = 0;
     866                 :      21291 :     PyObject *bytes_str = NULL;
     867                 :            : 
     868                 :            :     FstringParser state;
     869                 :      21291 :     _PyPegen_FstringParser_Init(&state);
     870                 :            : 
     871         [ +  + ]:      43360 :     for (Py_ssize_t i = 0; i < len; i++) {
     872                 :      22069 :         Token *t = asdl_seq_GET_UNTYPED(strings, i);
     873                 :            : 
     874                 :            :         int this_bytesmode;
     875                 :            :         int this_rawmode;
     876                 :            :         PyObject *s;
     877                 :            :         const char *fstr;
     878                 :      22069 :         Py_ssize_t fstrlen = -1;
     879                 :            : 
     880         [ -  + ]:      22069 :         if (_PyPegen_parsestr(p, &this_bytesmode, &this_rawmode, &s, &fstr, &fstrlen, t) != 0) {
     881                 :          0 :             goto error;
     882                 :            :         }
     883                 :            : 
     884                 :            :         /* Check that we are not mixing bytes with unicode. */
     885   [ +  +  -  + ]:      22069 :         if (i != 0 && bytesmode != this_bytesmode) {
     886                 :          0 :             RAISE_SYNTAX_ERROR("cannot mix bytes and nonbytes literals");
     887                 :          0 :             Py_XDECREF(s);
     888                 :          0 :             goto error;
     889                 :            :         }
     890                 :      22069 :         bytesmode = this_bytesmode;
     891                 :            : 
     892         [ +  + ]:      22069 :         if (fstr != NULL) {
     893                 :            :             assert(s == NULL && !bytesmode);
     894                 :            : 
     895                 :        992 :             int result = _PyPegen_FstringParser_ConcatFstring(p, &state, &fstr, fstr + fstrlen,
     896                 :            :                                                      this_rawmode, 0, first, t, last);
     897         [ -  + ]:        992 :             if (result < 0) {
     898                 :          0 :                 goto error;
     899                 :            :             }
     900                 :            :         }
     901                 :            :         else {
     902                 :            :             /* String or byte string. */
     903                 :            :             assert(s != NULL && fstr == NULL);
     904                 :            :             assert(bytesmode ? PyBytes_CheckExact(s) : PyUnicode_CheckExact(s));
     905                 :            : 
     906         [ +  + ]:      21077 :             if (bytesmode) {
     907         [ +  + ]:        280 :                 if (i == 0) {
     908                 :        271 :                     bytes_str = s;
     909                 :            :                 }
     910                 :            :                 else {
     911                 :          9 :                     PyBytes_ConcatAndDel(&bytes_str, s);
     912         [ -  + ]:          9 :                     if (!bytes_str) {
     913                 :          0 :                         goto error;
     914                 :            :                     }
     915                 :            :                 }
     916                 :            :             }
     917                 :            :             else {
     918                 :            :                 /* This is a regular string. Concatenate it. */
     919         [ -  + ]:      20797 :                 if (_PyPegen_FstringParser_ConcatAndDel(&state, s) < 0) {
     920                 :          0 :                     goto error;
     921                 :            :                 }
     922                 :            :             }
     923                 :            :         }
     924                 :            :     }
     925                 :            : 
     926         [ +  + ]:      21291 :     if (bytesmode) {
     927         [ -  + ]:        271 :         if (_PyArena_AddPyObject(p->arena, bytes_str) < 0) {
     928                 :          0 :             goto error;
     929                 :            :         }
     930                 :        271 :         return _PyAST_Constant(bytes_str, NULL, first->lineno,
     931                 :            :                                first->col_offset, last->end_lineno,
     932                 :            :                                last->end_col_offset, p->arena);
     933                 :            :     }
     934                 :            : 
     935                 :      21020 :     return _PyPegen_FstringParser_Finish(p, &state, first, last);
     936                 :            : 
     937                 :          0 : error:
     938                 :          0 :     Py_XDECREF(bytes_str);
     939                 :          0 :     _PyPegen_FstringParser_Dealloc(&state);
     940         [ #  # ]:          0 :     if (PyErr_Occurred()) {
     941                 :          0 :         _Pypegen_raise_decode_error(p);
     942                 :            :     }
     943                 :          0 :     return NULL;
     944                 :            : }
     945                 :            : 
     946                 :            : expr_ty
     947                 :          0 : _PyPegen_ensure_imaginary(Parser *p, expr_ty exp)
     948                 :            : {
     949   [ #  #  #  # ]:          0 :     if (exp->kind != Constant_kind || !PyComplex_CheckExact(exp->v.Constant.value)) {
     950                 :          0 :         RAISE_SYNTAX_ERROR_KNOWN_LOCATION(exp, "imaginary number required in complex literal");
     951                 :          0 :         return NULL;
     952                 :            :     }
     953                 :          0 :     return exp;
     954                 :            : }
     955                 :            : 
     956                 :            : expr_ty
     957                 :          0 : _PyPegen_ensure_real(Parser *p, expr_ty exp)
     958                 :            : {
     959   [ #  #  #  # ]:          0 :     if (exp->kind != Constant_kind || PyComplex_CheckExact(exp->v.Constant.value)) {
     960                 :          0 :         RAISE_SYNTAX_ERROR_KNOWN_LOCATION(exp, "real number required in complex literal");
     961                 :          0 :         return NULL;
     962                 :            :     }
     963                 :          0 :     return exp;
     964                 :            : }
     965                 :            : 
     966                 :            : mod_ty
     967                 :        215 : _PyPegen_make_module(Parser *p, asdl_stmt_seq *a) {
     968                 :        215 :     asdl_type_ignore_seq *type_ignores = NULL;
     969                 :        215 :     Py_ssize_t num = p->type_ignore_comments.num_items;
     970         [ -  + ]:        215 :     if (num > 0) {
     971                 :            :         // Turn the raw (comment, lineno) pairs into TypeIgnore objects in the arena
     972                 :          0 :         type_ignores = _Py_asdl_type_ignore_seq_new(num, p->arena);
     973         [ #  # ]:          0 :         if (type_ignores == NULL) {
     974                 :          0 :             return NULL;
     975                 :            :         }
     976         [ #  # ]:          0 :         for (int i = 0; i < num; i++) {
     977                 :          0 :             PyObject *tag = _PyPegen_new_type_comment(p, p->type_ignore_comments.items[i].comment);
     978         [ #  # ]:          0 :             if (tag == NULL) {
     979                 :          0 :                 return NULL;
     980                 :            :             }
     981                 :          0 :             type_ignore_ty ti = _PyAST_TypeIgnore(p->type_ignore_comments.items[i].lineno,
     982                 :            :                                                   tag, p->arena);
     983         [ #  # ]:          0 :             if (ti == NULL) {
     984                 :          0 :                 return NULL;
     985                 :            :             }
     986                 :          0 :             asdl_seq_SET(type_ignores, i, ti);
     987                 :            :         }
     988                 :            :     }
     989                 :        215 :     return _PyAST_Module(a, type_ignores, p->arena);
     990                 :            : }
     991                 :            : 
     992                 :            : PyObject *
     993                 :          0 : _PyPegen_new_type_comment(Parser *p, const char *s)
     994                 :            : {
     995                 :          0 :     PyObject *res = PyUnicode_DecodeUTF8(s, strlen(s), NULL);
     996         [ #  # ]:          0 :     if (res == NULL) {
     997                 :          0 :         return NULL;
     998                 :            :     }
     999         [ #  # ]:          0 :     if (_PyArena_AddPyObject(p->arena, res) < 0) {
    1000                 :          0 :         Py_DECREF(res);
    1001                 :          0 :         return NULL;
    1002                 :            :     }
    1003                 :          0 :     return res;
    1004                 :            : }
    1005                 :            : 
    1006                 :            : arg_ty
    1007                 :      57527 : _PyPegen_add_type_comment_to_arg(Parser *p, arg_ty a, Token *tc)
    1008                 :            : {
    1009         [ +  - ]:      57527 :     if (tc == NULL) {
    1010                 :      57527 :         return a;
    1011                 :            :     }
    1012                 :          0 :     const char *bytes = PyBytes_AsString(tc->bytes);
    1013         [ #  # ]:          0 :     if (bytes == NULL) {
    1014                 :          0 :         return NULL;
    1015                 :            :     }
    1016                 :          0 :     PyObject *tco = _PyPegen_new_type_comment(p, bytes);
    1017         [ #  # ]:          0 :     if (tco == NULL) {
    1018                 :          0 :         return NULL;
    1019                 :            :     }
    1020                 :          0 :     return _PyAST_arg(a->arg, a->annotation, tco,
    1021                 :            :                       a->lineno, a->col_offset, a->end_lineno, a->end_col_offset,
    1022                 :            :                       p->arena);
    1023                 :            : }
    1024                 :            : 
    1025                 :            : /* Checks if the NOTEQUAL token is valid given the current parser flags
    1026                 :            : 0 indicates success and nonzero indicates failure (an exception may be set) */
    1027                 :            : int
    1028                 :        437 : _PyPegen_check_barry_as_flufl(Parser *p, Token* t) {
    1029                 :            :     assert(t->bytes != NULL);
    1030                 :            :     assert(t->type == NOTEQUAL);
    1031                 :            : 
    1032                 :        437 :     const char* tok_str = PyBytes_AS_STRING(t->bytes);
    1033   [ -  +  -  - ]:        437 :     if (p->flags & PyPARSE_BARRY_AS_BDFL && strcmp(tok_str, "<>") != 0) {
    1034                 :          0 :         RAISE_SYNTAX_ERROR("with Barry as BDFL, use '<>' instead of '!='");
    1035                 :          0 :         return -1;
    1036                 :            :     }
    1037         [ +  - ]:        437 :     if (!(p->flags & PyPARSE_BARRY_AS_BDFL)) {
    1038                 :        437 :         return strcmp(tok_str, "!=");
    1039                 :            :     }
    1040                 :          0 :     return 0;
    1041                 :            : }
    1042                 :            : 
    1043                 :            : int
    1044                 :          0 : _PyPegen_check_legacy_stmt(Parser *p, expr_ty name) {
    1045         [ #  # ]:          0 :     if (name->kind != Name_kind) {
    1046                 :          0 :         return 0;
    1047                 :            :     }
    1048                 :          0 :     const char* candidates[2] = {"print", "exec"};
    1049         [ #  # ]:          0 :     for (int i=0; i<2; i++) {
    1050         [ #  # ]:          0 :         if (PyUnicode_CompareWithASCIIString(name->v.Name.id, candidates[i]) == 0) {
    1051                 :          0 :             return 1;
    1052                 :            :         }
    1053                 :            :     }
    1054                 :          0 :     return 0;
    1055                 :            : }
    1056                 :            : 
    1057                 :            : const char *
    1058                 :          0 : _PyPegen_get_expr_name(expr_ty e)
    1059                 :            : {
    1060                 :            :     assert(e != NULL);
    1061   [ #  #  #  #  :          0 :     switch (e->kind) {
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
    1062                 :          0 :         case Attribute_kind:
    1063                 :          0 :             return "attribute";
    1064                 :          0 :         case Subscript_kind:
    1065                 :          0 :             return "subscript";
    1066                 :          0 :         case Starred_kind:
    1067                 :          0 :             return "starred";
    1068                 :          0 :         case Name_kind:
    1069                 :          0 :             return "name";
    1070                 :          0 :         case List_kind:
    1071                 :          0 :             return "list";
    1072                 :          0 :         case Tuple_kind:
    1073                 :          0 :             return "tuple";
    1074                 :          0 :         case Lambda_kind:
    1075                 :          0 :             return "lambda";
    1076                 :          0 :         case Call_kind:
    1077                 :          0 :             return "function call";
    1078                 :          0 :         case BoolOp_kind:
    1079                 :            :         case BinOp_kind:
    1080                 :            :         case UnaryOp_kind:
    1081                 :          0 :             return "expression";
    1082                 :          0 :         case GeneratorExp_kind:
    1083                 :          0 :             return "generator expression";
    1084                 :          0 :         case Yield_kind:
    1085                 :            :         case YieldFrom_kind:
    1086                 :          0 :             return "yield expression";
    1087                 :          0 :         case Await_kind:
    1088                 :          0 :             return "await expression";
    1089                 :          0 :         case ListComp_kind:
    1090                 :          0 :             return "list comprehension";
    1091                 :          0 :         case SetComp_kind:
    1092                 :          0 :             return "set comprehension";
    1093                 :          0 :         case DictComp_kind:
    1094                 :          0 :             return "dict comprehension";
    1095                 :          0 :         case Dict_kind:
    1096                 :          0 :             return "dict literal";
    1097                 :          0 :         case Set_kind:
    1098                 :          0 :             return "set display";
    1099                 :          0 :         case JoinedStr_kind:
    1100                 :            :         case FormattedValue_kind:
    1101                 :          0 :             return "f-string expression";
    1102                 :          0 :         case Constant_kind: {
    1103                 :          0 :             PyObject *value = e->v.Constant.value;
    1104         [ #  # ]:          0 :             if (value == Py_None) {
    1105                 :          0 :                 return "None";
    1106                 :            :             }
    1107         [ #  # ]:          0 :             if (value == Py_False) {
    1108                 :          0 :                 return "False";
    1109                 :            :             }
    1110         [ #  # ]:          0 :             if (value == Py_True) {
    1111                 :          0 :                 return "True";
    1112                 :            :             }
    1113         [ #  # ]:          0 :             if (value == Py_Ellipsis) {
    1114                 :          0 :                 return "ellipsis";
    1115                 :            :             }
    1116                 :          0 :             return "literal";
    1117                 :            :         }
    1118                 :          0 :         case Compare_kind:
    1119                 :          0 :             return "comparison";
    1120                 :          0 :         case IfExp_kind:
    1121                 :          0 :             return "conditional expression";
    1122                 :          0 :         case NamedExpr_kind:
    1123                 :          0 :             return "named expression";
    1124                 :          0 :         default:
    1125                 :          0 :             PyErr_Format(PyExc_SystemError,
    1126                 :            :                          "unexpected expression in assignment %d (line %d)",
    1127                 :          0 :                          e->kind, e->lineno);
    1128                 :          0 :             return NULL;
    1129                 :            :     }
    1130                 :            : }
    1131                 :            : 
    1132                 :            : expr_ty
    1133                 :          0 : _PyPegen_get_last_comprehension_item(comprehension_ty comprehension) {
    1134   [ #  #  #  #  :          0 :     if (comprehension->ifs == NULL || asdl_seq_LEN(comprehension->ifs) == 0) {
                   #  # ]
    1135                 :          0 :         return comprehension->iter;
    1136                 :            :     }
    1137                 :          0 :     return PyPegen_last_item(comprehension->ifs, expr_ty);
    1138                 :            : }
    1139                 :            : 
    1140                 :      22264 : expr_ty _PyPegen_collect_call_seqs(Parser *p, asdl_expr_seq *a, asdl_seq *b,
    1141                 :            :                      int lineno, int col_offset, int end_lineno,
    1142                 :            :                      int end_col_offset, PyArena *arena) {
    1143         [ +  - ]:      22264 :     Py_ssize_t args_len = asdl_seq_LEN(a);
    1144                 :      22264 :     Py_ssize_t total_len = args_len;
    1145                 :            : 
    1146         [ +  + ]:      22264 :     if (b == NULL) {
    1147                 :      21219 :         return _PyAST_Call(_PyPegen_dummy_name(p), a, NULL, lineno, col_offset,
    1148                 :            :                         end_lineno, end_col_offset, arena);
    1149                 :            : 
    1150                 :            :     }
    1151                 :            : 
    1152                 :       1045 :     asdl_expr_seq *starreds = _PyPegen_seq_extract_starred_exprs(p, b);
    1153                 :       1045 :     asdl_keyword_seq *keywords = _PyPegen_seq_delete_starred_exprs(p, b);
    1154                 :            : 
    1155         [ -  + ]:       1045 :     if (starreds) {
    1156         [ #  # ]:          0 :         total_len += asdl_seq_LEN(starreds);
    1157                 :            :     }
    1158                 :            : 
    1159                 :       1045 :     asdl_expr_seq *args = _Py_asdl_expr_seq_new(total_len, arena);
    1160                 :            : 
    1161                 :       1045 :     Py_ssize_t i = 0;
    1162         [ +  + ]:       2846 :     for (i = 0; i < args_len; i++) {
    1163                 :       1801 :         asdl_seq_SET(args, i, asdl_seq_GET(a, i));
    1164                 :            :     }
    1165         [ -  + ]:       1045 :     for (; i < total_len; i++) {
    1166                 :          0 :         asdl_seq_SET(args, i, asdl_seq_GET(starreds, i - args_len));
    1167                 :            :     }
    1168                 :            : 
    1169                 :       1045 :     return _PyAST_Call(_PyPegen_dummy_name(p), args, keywords, lineno,
    1170                 :            :                        col_offset, end_lineno, end_col_offset, arena);
    1171                 :            : }
    1172                 :            : 
    1173                 :            : // AST Error reporting helpers
    1174                 :            : 
    1175                 :            : expr_ty
    1176                 :          0 : _PyPegen_get_invalid_target(expr_ty e, TARGETS_TYPE targets_type)
    1177                 :            : {
    1178         [ #  # ]:          0 :     if (e == NULL) {
    1179                 :          0 :         return NULL;
    1180                 :            :     }
    1181                 :            : 
    1182                 :            : #define VISIT_CONTAINER(CONTAINER, TYPE) do { \
    1183                 :            :         Py_ssize_t len = asdl_seq_LEN((CONTAINER)->v.TYPE.elts);\
    1184                 :            :         for (Py_ssize_t i = 0; i < len; i++) {\
    1185                 :            :             expr_ty other = asdl_seq_GET((CONTAINER)->v.TYPE.elts, i);\
    1186                 :            :             expr_ty child = _PyPegen_get_invalid_target(other, targets_type);\
    1187                 :            :             if (child != NULL) {\
    1188                 :            :                 return child;\
    1189                 :            :             }\
    1190                 :            :         }\
    1191                 :            :     } while (0)
    1192                 :            : 
    1193                 :            :     // We only need to visit List and Tuple nodes recursively as those
    1194                 :            :     // are the only ones that can contain valid names in targets when
    1195                 :            :     // they are parsed as expressions. Any other kind of expression
    1196                 :            :     // that is a container (like Sets or Dicts) is directly invalid and
    1197                 :            :     // we don't need to visit it recursively.
    1198                 :            : 
    1199   [ #  #  #  #  :          0 :     switch (e->kind) {
                   #  # ]
    1200                 :          0 :         case List_kind:
    1201   [ #  #  #  #  :          0 :             VISIT_CONTAINER(e, List);
                   #  # ]
    1202                 :          0 :             return NULL;
    1203                 :          0 :         case Tuple_kind:
    1204   [ #  #  #  #  :          0 :             VISIT_CONTAINER(e, Tuple);
                   #  # ]
    1205                 :          0 :             return NULL;
    1206                 :          0 :         case Starred_kind:
    1207         [ #  # ]:          0 :             if (targets_type == DEL_TARGETS) {
    1208                 :          0 :                 return e;
    1209                 :            :             }
    1210                 :          0 :             return _PyPegen_get_invalid_target(e->v.Starred.value, targets_type);
    1211                 :          0 :         case Compare_kind:
    1212                 :            :             // This is needed, because the `a in b` in `for a in b` gets parsed
    1213                 :            :             // as a comparison, and so we need to search the left side of the comparison
    1214                 :            :             // for invalid targets.
    1215         [ #  # ]:          0 :             if (targets_type == FOR_TARGETS) {
    1216                 :          0 :                 cmpop_ty cmpop = (cmpop_ty) asdl_seq_GET(e->v.Compare.ops, 0);
    1217         [ #  # ]:          0 :                 if (cmpop == In) {
    1218                 :          0 :                     return _PyPegen_get_invalid_target(e->v.Compare.left, targets_type);
    1219                 :            :                 }
    1220                 :          0 :                 return NULL;
    1221                 :            :             }
    1222                 :          0 :             return e;
    1223                 :          0 :         case Name_kind:
    1224                 :            :         case Subscript_kind:
    1225                 :            :         case Attribute_kind:
    1226                 :          0 :             return NULL;
    1227                 :          0 :         default:
    1228                 :          0 :             return e;
    1229                 :            :     }
    1230                 :            : }
    1231                 :            : 
    1232                 :          0 : void *_PyPegen_arguments_parsing_error(Parser *p, expr_ty e) {
    1233                 :          0 :     int kwarg_unpacking = 0;
    1234   [ #  #  #  # ]:          0 :     for (Py_ssize_t i = 0, l = asdl_seq_LEN(e->v.Call.keywords); i < l; i++) {
    1235                 :          0 :         keyword_ty keyword = asdl_seq_GET(e->v.Call.keywords, i);
    1236         [ #  # ]:          0 :         if (!keyword->arg) {
    1237                 :          0 :             kwarg_unpacking = 1;
    1238                 :            :         }
    1239                 :            :     }
    1240                 :            : 
    1241                 :          0 :     const char *msg = NULL;
    1242         [ #  # ]:          0 :     if (kwarg_unpacking) {
    1243                 :          0 :         msg = "positional argument follows keyword argument unpacking";
    1244                 :            :     } else {
    1245                 :          0 :         msg = "positional argument follows keyword argument";
    1246                 :            :     }
    1247                 :            : 
    1248                 :          0 :     return RAISE_SYNTAX_ERROR(msg);
    1249                 :            : }
    1250                 :            : 
    1251                 :            : void *
    1252                 :          0 : _PyPegen_nonparen_genexp_in_call(Parser *p, expr_ty args, asdl_comprehension_seq *comprehensions)
    1253                 :            : {
    1254                 :            :     /* The rule that calls this function is 'args for_if_clauses'.
    1255                 :            :        For the input f(L, x for x in y), L and x are in args and
    1256                 :            :        the for is parsed as a for_if_clause. We have to check if
    1257                 :            :        len <= 1, so that input like dict((a, b) for a, b in x)
    1258                 :            :        gets successfully parsed and then we pass the last
    1259                 :            :        argument (x in the above example) as the location of the
    1260                 :            :        error */
    1261         [ #  # ]:          0 :     Py_ssize_t len = asdl_seq_LEN(args->v.Call.args);
    1262         [ #  # ]:          0 :     if (len <= 1) {
    1263                 :          0 :         return NULL;
    1264                 :            :     }
    1265                 :            : 
    1266                 :          0 :     comprehension_ty last_comprehension = PyPegen_last_item(comprehensions, comprehension_ty);
    1267                 :            : 
    1268                 :          0 :     return RAISE_SYNTAX_ERROR_KNOWN_RANGE(
    1269                 :            :         (expr_ty) asdl_seq_GET(args->v.Call.args, len - 1),
    1270                 :            :         _PyPegen_get_last_comprehension_item(last_comprehension),
    1271                 :            :         "Generator expression must be parenthesized"
    1272                 :            :     );
    1273                 :            : }

Generated by: LCOV version 1.14