LCOV - code coverage report
Current view: top level - Python - symtable.c (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 841 1213 69.3 %
Date: 2023-03-20 08:15:36 Functions: 44 49 89.8 %
Branches: 721 1242 58.1 %

           Branch data     Line data    Source code
       1                 :            : #include "Python.h"
       2                 :            : #include "pycore_ast.h"           // identifier, stmt_ty
       3                 :            : #include "pycore_parser.h"        // _PyParser_ASTFromString()
       4                 :            : #include "pycore_pystate.h"       // _PyThreadState_GET()
       5                 :            : #include "pycore_symtable.h"      // PySTEntryObject
       6                 :            : #include "structmember.h"         // PyMemberDef
       7                 :            : 
       8                 :            : /* error strings used for warnings */
       9                 :            : #define GLOBAL_PARAM \
      10                 :            : "name '%U' is parameter and global"
      11                 :            : 
      12                 :            : #define NONLOCAL_PARAM \
      13                 :            : "name '%U' is parameter and nonlocal"
      14                 :            : 
      15                 :            : #define GLOBAL_AFTER_ASSIGN \
      16                 :            : "name '%U' is assigned to before global declaration"
      17                 :            : 
      18                 :            : #define NONLOCAL_AFTER_ASSIGN \
      19                 :            : "name '%U' is assigned to before nonlocal declaration"
      20                 :            : 
      21                 :            : #define GLOBAL_AFTER_USE \
      22                 :            : "name '%U' is used prior to global declaration"
      23                 :            : 
      24                 :            : #define NONLOCAL_AFTER_USE \
      25                 :            : "name '%U' is used prior to nonlocal declaration"
      26                 :            : 
      27                 :            : #define GLOBAL_ANNOT \
      28                 :            : "annotated name '%U' can't be global"
      29                 :            : 
      30                 :            : #define NONLOCAL_ANNOT \
      31                 :            : "annotated name '%U' can't be nonlocal"
      32                 :            : 
      33                 :            : #define IMPORT_STAR_WARNING "import * only allowed at module level"
      34                 :            : 
      35                 :            : #define NAMED_EXPR_COMP_IN_CLASS \
      36                 :            : "assignment expression within a comprehension cannot be used in a class body"
      37                 :            : 
      38                 :            : #define NAMED_EXPR_COMP_CONFLICT \
      39                 :            : "assignment expression cannot rebind comprehension iteration variable '%U'"
      40                 :            : 
      41                 :            : #define NAMED_EXPR_COMP_INNER_LOOP_CONFLICT \
      42                 :            : "comprehension inner loop cannot rebind assignment expression target '%U'"
      43                 :            : 
      44                 :            : #define NAMED_EXPR_COMP_ITER_EXPR \
      45                 :            : "assignment expression cannot be used in a comprehension iterable expression"
      46                 :            : 
      47                 :            : #define ANNOTATION_NOT_ALLOWED \
      48                 :            : "'%s' can not be used within an annotation"
      49                 :            : 
      50                 :            : 
      51                 :            : #define LOCATION(x) \
      52                 :            :  (x)->lineno, (x)->col_offset, (x)->end_lineno, (x)->end_col_offset
      53                 :            : 
      54                 :            : #define ST_LOCATION(x) \
      55                 :            :  (x)->ste_lineno, (x)->ste_col_offset, (x)->ste_end_lineno, (x)->ste_end_col_offset
      56                 :            : 
      57                 :            : static PySTEntryObject *
      58                 :       8037 : ste_new(struct symtable *st, identifier name, _Py_block_ty block,
      59                 :            :         void *key, int lineno, int col_offset,
      60                 :            :         int end_lineno, int end_col_offset)
      61                 :            : {
      62                 :       8037 :     PySTEntryObject *ste = NULL;
      63                 :       8037 :     PyObject *k = NULL;
      64                 :            : 
      65                 :       8037 :     k = PyLong_FromVoidPtr(key);
      66         [ -  + ]:       8037 :     if (k == NULL)
      67                 :          0 :         goto fail;
      68                 :       8037 :     ste = PyObject_New(PySTEntryObject, &PySTEntry_Type);
      69         [ -  + ]:       8037 :     if (ste == NULL) {
      70                 :          0 :         Py_DECREF(k);
      71                 :          0 :         goto fail;
      72                 :            :     }
      73                 :       8037 :     ste->ste_table = st;
      74                 :       8037 :     ste->ste_id = k; /* ste owns reference to k */
      75                 :            : 
      76                 :       8037 :     ste->ste_name = Py_NewRef(name);
      77                 :            : 
      78                 :       8037 :     ste->ste_symbols = NULL;
      79                 :       8037 :     ste->ste_varnames = NULL;
      80                 :       8037 :     ste->ste_children = NULL;
      81                 :            : 
      82                 :       8037 :     ste->ste_directives = NULL;
      83                 :            : 
      84                 :       8037 :     ste->ste_type = block;
      85                 :       8037 :     ste->ste_nested = 0;
      86                 :       8037 :     ste->ste_free = 0;
      87                 :       8037 :     ste->ste_varargs = 0;
      88                 :       8037 :     ste->ste_varkeywords = 0;
      89                 :       8037 :     ste->ste_opt_lineno = 0;
      90                 :       8037 :     ste->ste_opt_col_offset = 0;
      91                 :       8037 :     ste->ste_lineno = lineno;
      92                 :       8037 :     ste->ste_col_offset = col_offset;
      93                 :       8037 :     ste->ste_end_lineno = end_lineno;
      94                 :       8037 :     ste->ste_end_col_offset = end_col_offset;
      95                 :            : 
      96         [ +  + ]:       8037 :     if (st->st_cur != NULL &&
      97         [ +  + ]:       7718 :         (st->st_cur->ste_nested ||
      98         [ +  + ]:       7658 :          st->st_cur->ste_type == FunctionBlock))
      99                 :        779 :         ste->ste_nested = 1;
     100                 :       8037 :     ste->ste_child_free = 0;
     101                 :       8037 :     ste->ste_generator = 0;
     102                 :       8037 :     ste->ste_coroutine = 0;
     103                 :       8037 :     ste->ste_comprehension = NoComprehension;
     104                 :       8037 :     ste->ste_returns_value = 0;
     105                 :       8037 :     ste->ste_needs_class_closure = 0;
     106                 :       8037 :     ste->ste_comp_iter_target = 0;
     107                 :       8037 :     ste->ste_comp_iter_expr = 0;
     108                 :            : 
     109                 :       8037 :     ste->ste_symbols = PyDict_New();
     110                 :       8037 :     ste->ste_varnames = PyList_New(0);
     111                 :       8037 :     ste->ste_children = PyList_New(0);
     112         [ +  - ]:       8037 :     if (ste->ste_symbols == NULL
     113         [ +  - ]:       8037 :         || ste->ste_varnames == NULL
     114         [ -  + ]:       8037 :         || ste->ste_children == NULL)
     115                 :          0 :         goto fail;
     116                 :            : 
     117         [ -  + ]:       8037 :     if (PyDict_SetItem(st->st_blocks, ste->ste_id, (PyObject *)ste) < 0)
     118                 :          0 :         goto fail;
     119                 :            : 
     120                 :       8037 :     return ste;
     121                 :          0 :  fail:
     122                 :          0 :     Py_XDECREF(ste);
     123                 :          0 :     return NULL;
     124                 :            : }
     125                 :            : 
     126                 :            : static PyObject *
     127                 :          0 : ste_repr(PySTEntryObject *ste)
     128                 :            : {
     129                 :          0 :     return PyUnicode_FromFormat("<symtable entry %U(%ld), line %d>",
     130                 :            :                                 ste->ste_name,
     131                 :            :                                 PyLong_AS_LONG(ste->ste_id), ste->ste_lineno);
     132                 :            : }
     133                 :            : 
     134                 :            : static void
     135                 :       8037 : ste_dealloc(PySTEntryObject *ste)
     136                 :            : {
     137                 :       8037 :     ste->ste_table = NULL;
     138                 :       8037 :     Py_XDECREF(ste->ste_id);
     139                 :       8037 :     Py_XDECREF(ste->ste_name);
     140                 :       8037 :     Py_XDECREF(ste->ste_symbols);
     141                 :       8037 :     Py_XDECREF(ste->ste_varnames);
     142                 :       8037 :     Py_XDECREF(ste->ste_children);
     143                 :       8037 :     Py_XDECREF(ste->ste_directives);
     144                 :       8037 :     PyObject_Free(ste);
     145                 :       8037 : }
     146                 :            : 
     147                 :            : #define OFF(x) offsetof(PySTEntryObject, x)
     148                 :            : 
     149                 :            : static PyMemberDef ste_memberlist[] = {
     150                 :            :     {"id",       T_OBJECT, OFF(ste_id), READONLY},
     151                 :            :     {"name",     T_OBJECT, OFF(ste_name), READONLY},
     152                 :            :     {"symbols",  T_OBJECT, OFF(ste_symbols), READONLY},
     153                 :            :     {"varnames", T_OBJECT, OFF(ste_varnames), READONLY},
     154                 :            :     {"children", T_OBJECT, OFF(ste_children), READONLY},
     155                 :            :     {"nested",   T_INT,    OFF(ste_nested), READONLY},
     156                 :            :     {"type",     T_INT,    OFF(ste_type), READONLY},
     157                 :            :     {"lineno",   T_INT,    OFF(ste_lineno), READONLY},
     158                 :            :     {NULL}
     159                 :            : };
     160                 :            : 
     161                 :            : PyTypeObject PySTEntry_Type = {
     162                 :            :     PyVarObject_HEAD_INIT(&PyType_Type, 0)
     163                 :            :     "symtable entry",
     164                 :            :     sizeof(PySTEntryObject),
     165                 :            :     0,
     166                 :            :     (destructor)ste_dealloc,                /* tp_dealloc */
     167                 :            :     0,                                      /* tp_vectorcall_offset */
     168                 :            :     0,                                         /* tp_getattr */
     169                 :            :     0,                                          /* tp_setattr */
     170                 :            :     0,                                          /* tp_as_async */
     171                 :            :     (reprfunc)ste_repr,                         /* tp_repr */
     172                 :            :     0,                                          /* tp_as_number */
     173                 :            :     0,                                          /* tp_as_sequence */
     174                 :            :     0,                                          /* tp_as_mapping */
     175                 :            :     0,                                          /* tp_hash */
     176                 :            :     0,                                          /* tp_call */
     177                 :            :     0,                                          /* tp_str */
     178                 :            :     PyObject_GenericGetAttr,                    /* tp_getattro */
     179                 :            :     0,                                          /* tp_setattro */
     180                 :            :     0,                                          /* tp_as_buffer */
     181                 :            :     Py_TPFLAGS_DEFAULT,                         /* tp_flags */
     182                 :            :     0,                                          /* tp_doc */
     183                 :            :     0,                                          /* tp_traverse */
     184                 :            :     0,                                          /* tp_clear */
     185                 :            :     0,                                          /* tp_richcompare */
     186                 :            :     0,                                          /* tp_weaklistoffset */
     187                 :            :     0,                                          /* tp_iter */
     188                 :            :     0,                                          /* tp_iternext */
     189                 :            :     0,                                          /* tp_methods */
     190                 :            :     ste_memberlist,                             /* tp_members */
     191                 :            :     0,                                          /* tp_getset */
     192                 :            :     0,                                          /* tp_base */
     193                 :            :     0,                                          /* tp_dict */
     194                 :            :     0,                                          /* tp_descr_get */
     195                 :            :     0,                                          /* tp_descr_set */
     196                 :            :     0,                                          /* tp_dictoffset */
     197                 :            :     0,                                          /* tp_init */
     198                 :            :     0,                                          /* tp_alloc */
     199                 :            :     0,                                          /* tp_new */
     200                 :            : };
     201                 :            : 
     202                 :            : static int symtable_analyze(struct symtable *st);
     203                 :            : static int symtable_enter_block(struct symtable *st, identifier name,
     204                 :            :                                 _Py_block_ty block, void *ast,
     205                 :            :                                 int lineno, int col_offset,
     206                 :            :                                 int end_lineno, int end_col_offset);
     207                 :            : static int symtable_exit_block(struct symtable *st);
     208                 :            : static int symtable_visit_stmt(struct symtable *st, stmt_ty s);
     209                 :            : static int symtable_visit_expr(struct symtable *st, expr_ty s);
     210                 :            : static int symtable_visit_genexp(struct symtable *st, expr_ty s);
     211                 :            : static int symtable_visit_listcomp(struct symtable *st, expr_ty s);
     212                 :            : static int symtable_visit_setcomp(struct symtable *st, expr_ty s);
     213                 :            : static int symtable_visit_dictcomp(struct symtable *st, expr_ty s);
     214                 :            : static int symtable_visit_arguments(struct symtable *st, arguments_ty);
     215                 :            : static int symtable_visit_excepthandler(struct symtable *st, excepthandler_ty);
     216                 :            : static int symtable_visit_alias(struct symtable *st, alias_ty);
     217                 :            : static int symtable_visit_comprehension(struct symtable *st, comprehension_ty);
     218                 :            : static int symtable_visit_keyword(struct symtable *st, keyword_ty);
     219                 :            : static int symtable_visit_params(struct symtable *st, asdl_arg_seq *args);
     220                 :            : static int symtable_visit_annotation(struct symtable *st, expr_ty annotation);
     221                 :            : static int symtable_visit_argannotations(struct symtable *st, asdl_arg_seq *args);
     222                 :            : static int symtable_implicit_arg(struct symtable *st, int pos);
     223                 :            : static int symtable_visit_annotations(struct symtable *st, stmt_ty, arguments_ty, expr_ty);
     224                 :            : static int symtable_visit_withitem(struct symtable *st, withitem_ty item);
     225                 :            : static int symtable_visit_match_case(struct symtable *st, match_case_ty m);
     226                 :            : static int symtable_visit_pattern(struct symtable *st, pattern_ty s);
     227                 :            : static int symtable_raise_if_annotation_block(struct symtable *st, const char *, expr_ty);
     228                 :            : static int symtable_raise_if_comprehension_block(struct symtable *st, expr_ty);
     229                 :            : 
     230                 :            : 
     231                 :            : #define DUPLICATE_ARGUMENT \
     232                 :            : "duplicate argument '%U' in function definition"
     233                 :            : 
     234                 :            : static struct symtable *
     235                 :        319 : symtable_new(void)
     236                 :            : {
     237                 :            :     struct symtable *st;
     238                 :            : 
     239                 :        319 :     st = (struct symtable *)PyMem_Malloc(sizeof(struct symtable));
     240         [ -  + ]:        319 :     if (st == NULL) {
     241                 :          0 :         PyErr_NoMemory();
     242                 :          0 :         return NULL;
     243                 :            :     }
     244                 :            : 
     245                 :        319 :     st->st_filename = NULL;
     246                 :        319 :     st->st_blocks = NULL;
     247                 :            : 
     248         [ -  + ]:        319 :     if ((st->st_stack = PyList_New(0)) == NULL)
     249                 :          0 :         goto fail;
     250         [ -  + ]:        319 :     if ((st->st_blocks = PyDict_New()) == NULL)
     251                 :          0 :         goto fail;
     252                 :        319 :     st->st_cur = NULL;
     253                 :        319 :     st->st_private = NULL;
     254                 :        319 :     return st;
     255                 :          0 :  fail:
     256                 :          0 :     _PySymtable_Free(st);
     257                 :          0 :     return NULL;
     258                 :            : }
     259                 :            : 
     260                 :            : /* When compiling the use of C stack is probably going to be a lot
     261                 :            :    lighter than when executing Python code but still can overflow
     262                 :            :    and causing a Python crash if not checked (e.g. eval("()"*300000)).
     263                 :            :    Using the current recursion limit for the compiler seems too
     264                 :            :    restrictive (it caused at least one test to fail) so a factor is
     265                 :            :    used to allow deeper recursion when compiling an expression.
     266                 :            : 
     267                 :            :    Using a scaling factor means this should automatically adjust when
     268                 :            :    the recursion limit is adjusted for small or large C stack allocations.
     269                 :            : */
     270                 :            : #define COMPILER_STACK_FRAME_SCALE 3
     271                 :            : 
     272                 :            : struct symtable *
     273                 :        319 : _PySymtable_Build(mod_ty mod, PyObject *filename, PyFutureFeatures *future)
     274                 :            : {
     275                 :        319 :     struct symtable *st = symtable_new();
     276                 :            :     asdl_stmt_seq *seq;
     277                 :            :     int i;
     278                 :            :     PyThreadState *tstate;
     279                 :            :     int starting_recursion_depth;
     280                 :            : 
     281         [ -  + ]:        319 :     if (st == NULL)
     282                 :          0 :         return NULL;
     283         [ -  + ]:        319 :     if (filename == NULL) {
     284                 :          0 :         _PySymtable_Free(st);
     285                 :          0 :         return NULL;
     286                 :            :     }
     287                 :        319 :     st->st_filename = Py_NewRef(filename);
     288                 :        319 :     st->st_future = future;
     289                 :            : 
     290                 :            :     /* Setup recursion depth check counters */
     291                 :        319 :     tstate = _PyThreadState_GET();
     292         [ -  + ]:        319 :     if (!tstate) {
     293                 :          0 :         _PySymtable_Free(st);
     294                 :          0 :         return NULL;
     295                 :            :     }
     296                 :            :     /* Be careful here to prevent overflow. */
     297                 :        319 :     int recursion_depth = C_RECURSION_LIMIT - tstate->c_recursion_remaining;
     298                 :        319 :     starting_recursion_depth = recursion_depth * COMPILER_STACK_FRAME_SCALE;
     299                 :        319 :     st->recursion_depth = starting_recursion_depth;
     300                 :        319 :     st->recursion_limit = C_RECURSION_LIMIT * COMPILER_STACK_FRAME_SCALE;
     301                 :            : 
     302                 :            :     /* Make the initial symbol information gathering pass */
     303         [ -  + ]:        319 :     if (!symtable_enter_block(st, &_Py_ID(top), ModuleBlock, (void *)mod, 0, 0, 0, 0)) {
     304                 :          0 :         _PySymtable_Free(st);
     305                 :          0 :         return NULL;
     306                 :            :     }
     307                 :            : 
     308                 :        319 :     st->st_top = st->st_cur;
     309   [ +  +  +  -  :        319 :     switch (mod->kind) {
                      - ]
     310                 :        206 :     case Module_kind:
     311                 :        206 :         seq = mod->v.Module.body;
     312   [ +  +  +  + ]:       6070 :         for (i = 0; i < asdl_seq_LEN(seq); i++)
     313         [ -  + ]:       5864 :             if (!symtable_visit_stmt(st,
     314                 :       5864 :                         (stmt_ty)asdl_seq_GET(seq, i)))
     315                 :          0 :                 goto error;
     316                 :        206 :         break;
     317                 :         57 :     case Expression_kind:
     318         [ -  + ]:         57 :         if (!symtable_visit_expr(st, mod->v.Expression.body))
     319                 :          0 :             goto error;
     320                 :         57 :         break;
     321                 :         56 :     case Interactive_kind:
     322                 :         56 :         seq = mod->v.Interactive.body;
     323   [ +  -  +  + ]:        112 :         for (i = 0; i < asdl_seq_LEN(seq); i++)
     324         [ -  + ]:         56 :             if (!symtable_visit_stmt(st,
     325                 :         56 :                         (stmt_ty)asdl_seq_GET(seq, i)))
     326                 :          0 :                 goto error;
     327                 :         56 :         break;
     328                 :          0 :     case FunctionType_kind:
     329                 :          0 :         PyErr_SetString(PyExc_RuntimeError,
     330                 :            :                         "this compiler does not handle FunctionTypes");
     331                 :          0 :         goto error;
     332                 :            :     }
     333         [ -  + ]:        319 :     if (!symtable_exit_block(st)) {
     334                 :          0 :         _PySymtable_Free(st);
     335                 :          0 :         return NULL;
     336                 :            :     }
     337                 :            :     /* Check that the recursion depth counting balanced correctly */
     338         [ -  + ]:        319 :     if (st->recursion_depth != starting_recursion_depth) {
     339                 :          0 :         PyErr_Format(PyExc_SystemError,
     340                 :            :             "symtable analysis recursion depth mismatch (before=%d, after=%d)",
     341                 :            :             starting_recursion_depth, st->recursion_depth);
     342                 :          0 :         _PySymtable_Free(st);
     343                 :          0 :         return NULL;
     344                 :            :     }
     345                 :            :     /* Make the second symbol analysis pass */
     346         [ +  - ]:        319 :     if (symtable_analyze(st))
     347                 :        319 :         return st;
     348                 :          0 :     _PySymtable_Free(st);
     349                 :          0 :     return NULL;
     350                 :          0 :  error:
     351                 :          0 :     (void) symtable_exit_block(st);
     352                 :          0 :     _PySymtable_Free(st);
     353                 :          0 :     return NULL;
     354                 :            : }
     355                 :            : 
     356                 :            : 
     357                 :            : void
     358                 :        319 : _PySymtable_Free(struct symtable *st)
     359                 :            : {
     360                 :        319 :     Py_XDECREF(st->st_filename);
     361                 :        319 :     Py_XDECREF(st->st_blocks);
     362                 :        319 :     Py_XDECREF(st->st_stack);
     363                 :        319 :     PyMem_Free((void *)st);
     364                 :        319 : }
     365                 :            : 
     366                 :            : PySTEntryObject *
     367                 :       8041 : PySymtable_Lookup(struct symtable *st, void *key)
     368                 :            : {
     369                 :            :     PyObject *k, *v;
     370                 :            : 
     371                 :       8041 :     k = PyLong_FromVoidPtr(key);
     372         [ -  + ]:       8041 :     if (k == NULL)
     373                 :          0 :         return NULL;
     374                 :       8041 :     v = PyDict_GetItemWithError(st->st_blocks, k);
     375                 :       8041 :     Py_DECREF(k);
     376                 :            : 
     377         [ -  + ]:       8041 :     if (v) {
     378                 :            :         assert(PySTEntry_Check(v));
     379                 :            :     }
     380         [ #  # ]:          0 :     else if (!PyErr_Occurred()) {
     381                 :          0 :         PyErr_SetString(PyExc_KeyError,
     382                 :            :                         "unknown symbol table entry");
     383                 :            :     }
     384                 :            : 
     385                 :       8041 :     return (PySTEntryObject *)Py_XNewRef(v);
     386                 :            : }
     387                 :            : 
     388                 :            : long
     389                 :     132089 : _PyST_GetSymbol(PySTEntryObject *ste, PyObject *name)
     390                 :            : {
     391                 :     132089 :     PyObject *v = PyDict_GetItemWithError(ste->ste_symbols, name);
     392         [ +  + ]:     132089 :     if (!v)
     393                 :      10580 :         return 0;
     394                 :            :     assert(PyLong_Check(v));
     395                 :     121509 :     return PyLong_AS_LONG(v);
     396                 :            : }
     397                 :            : 
     398                 :            : int
     399                 :     121103 : _PyST_GetScope(PySTEntryObject *ste, PyObject *name)
     400                 :            : {
     401                 :     121103 :     long symbol = _PyST_GetSymbol(ste, name);
     402                 :     121103 :     return (symbol >> SCOPE_OFFSET) & SCOPE_MASK;
     403                 :            : }
     404                 :            : 
     405                 :            : static int
     406                 :          0 : error_at_directive(PySTEntryObject *ste, PyObject *name)
     407                 :            : {
     408                 :            :     Py_ssize_t i;
     409                 :            :     PyObject *data;
     410                 :            :     assert(ste->ste_directives);
     411         [ #  # ]:          0 :     for (i = 0; i < PyList_GET_SIZE(ste->ste_directives); i++) {
     412                 :          0 :         data = PyList_GET_ITEM(ste->ste_directives, i);
     413                 :            :         assert(PyTuple_CheckExact(data));
     414                 :            :         assert(PyUnicode_CheckExact(PyTuple_GET_ITEM(data, 0)));
     415         [ #  # ]:          0 :         if (PyUnicode_Compare(PyTuple_GET_ITEM(data, 0), name) == 0) {
     416                 :          0 :             PyErr_RangedSyntaxLocationObject(ste->ste_table->st_filename,
     417                 :          0 :                                              PyLong_AsLong(PyTuple_GET_ITEM(data, 1)),
     418                 :          0 :                                              PyLong_AsLong(PyTuple_GET_ITEM(data, 2)) + 1,
     419                 :          0 :                                              PyLong_AsLong(PyTuple_GET_ITEM(data, 3)),
     420                 :          0 :                                              PyLong_AsLong(PyTuple_GET_ITEM(data, 4)) + 1);
     421                 :            : 
     422                 :          0 :             return 0;
     423                 :            :         }
     424                 :            :     }
     425                 :          0 :     PyErr_SetString(PyExc_RuntimeError,
     426                 :            :                     "BUG: internal directive bookkeeping broken");
     427                 :          0 :     return 0;
     428                 :            : }
     429                 :            : 
     430                 :            : 
     431                 :            : /* Analyze raw symbol information to determine scope of each name.
     432                 :            : 
     433                 :            :    The next several functions are helpers for symtable_analyze(),
     434                 :            :    which determines whether a name is local, global, or free.  In addition,
     435                 :            :    it determines which local variables are cell variables; they provide
     436                 :            :    bindings that are used for free variables in enclosed blocks.
     437                 :            : 
     438                 :            :    There are also two kinds of global variables, implicit and explicit.  An
     439                 :            :    explicit global is declared with the global statement.  An implicit
     440                 :            :    global is a free variable for which the compiler has found no binding
     441                 :            :    in an enclosing function scope.  The implicit global is either a global
     442                 :            :    or a builtin.  Python's module and class blocks use the xxx_NAME opcodes
     443                 :            :    to handle these names to implement slightly odd semantics.  In such a
     444                 :            :    block, the name is treated as global until it is assigned to; then it
     445                 :            :    is treated as a local.
     446                 :            : 
     447                 :            :    The symbol table requires two passes to determine the scope of each name.
     448                 :            :    The first pass collects raw facts from the AST via the symtable_visit_*
     449                 :            :    functions: the name is a parameter here, the name is used but not defined
     450                 :            :    here, etc.  The second pass analyzes these facts during a pass over the
     451                 :            :    PySTEntryObjects created during pass 1.
     452                 :            : 
     453                 :            :    When a function is entered during the second pass, the parent passes
     454                 :            :    the set of all name bindings visible to its children.  These bindings
     455                 :            :    are used to determine if non-local variables are free or implicit globals.
     456                 :            :    Names which are explicitly declared nonlocal must exist in this set of
     457                 :            :    visible names - if they do not, a syntax error is raised. After doing
     458                 :            :    the local analysis, it analyzes each of its child blocks using an
     459                 :            :    updated set of name bindings.
     460                 :            : 
     461                 :            :    The children update the free variable set.  If a local variable is added to
     462                 :            :    the free variable set by the child, the variable is marked as a cell.  The
     463                 :            :    function object being defined must provide runtime storage for the variable
     464                 :            :    that may outlive the function's frame.  Cell variables are removed from the
     465                 :            :    free set before the analyze function returns to its parent.
     466                 :            : 
     467                 :            :    During analysis, the names are:
     468                 :            :       symbols: dict mapping from symbol names to flag values (including offset scope values)
     469                 :            :       scopes: dict mapping from symbol names to scope values (no offset)
     470                 :            :       local: set of all symbol names local to the current scope
     471                 :            :       bound: set of all symbol names local to a containing function scope
     472                 :            :       free: set of all symbol names referenced but not bound in child scopes
     473                 :            :       global: set of all symbol names explicitly declared as global
     474                 :            : */
     475                 :            : 
     476                 :            : #define SET_SCOPE(DICT, NAME, I) { \
     477                 :            :     PyObject *o = PyLong_FromLong(I); \
     478                 :            :     if (!o) \
     479                 :            :         return 0; \
     480                 :            :     if (PyDict_SetItem((DICT), (NAME), o) < 0) { \
     481                 :            :         Py_DECREF(o); \
     482                 :            :         return 0; \
     483                 :            :     } \
     484                 :            :     Py_DECREF(o); \
     485                 :            : }
     486                 :            : 
     487                 :            : /* Decide on scope of name, given flags.
     488                 :            : 
     489                 :            :    The namespace dictionaries may be modified to record information
     490                 :            :    about the new name.  For example, a new global will add an entry to
     491                 :            :    global.  A name that was global can be changed to local.
     492                 :            : */
     493                 :            : 
     494                 :            : static int
     495                 :      51080 : analyze_name(PySTEntryObject *ste, PyObject *scopes, PyObject *name, long flags,
     496                 :            :              PyObject *bound, PyObject *local, PyObject *free,
     497                 :            :              PyObject *global)
     498                 :            : {
     499         [ +  + ]:      51080 :     if (flags & DEF_GLOBAL) {
     500         [ -  + ]:        159 :         if (flags & DEF_NONLOCAL) {
     501                 :          0 :             PyErr_Format(PyExc_SyntaxError,
     502                 :            :                          "name '%U' is nonlocal and global",
     503                 :            :                          name);
     504                 :          0 :             return error_at_directive(ste, name);
     505                 :            :         }
     506   [ -  +  -  + ]:        159 :         SET_SCOPE(scopes, name, GLOBAL_EXPLICIT);
     507         [ -  + ]:        159 :         if (PySet_Add(global, name) < 0)
     508                 :          0 :             return 0;
     509   [ +  +  -  + ]:        159 :         if (bound && (PySet_Discard(bound, name) < 0))
     510                 :          0 :             return 0;
     511                 :        159 :         return 1;
     512                 :            :     }
     513         [ +  + ]:      50921 :     if (flags & DEF_NONLOCAL) {
     514         [ -  + ]:         24 :         if (!bound) {
     515                 :          0 :             PyErr_Format(PyExc_SyntaxError,
     516                 :            :                          "nonlocal declaration not allowed at module level");
     517                 :          0 :             return error_at_directive(ste, name);
     518                 :            :         }
     519         [ -  + ]:         24 :         if (!PySet_Contains(bound, name)) {
     520                 :          0 :             PyErr_Format(PyExc_SyntaxError,
     521                 :            :                          "no binding for nonlocal '%U' found",
     522                 :            :                          name);
     523                 :            : 
     524                 :          0 :             return error_at_directive(ste, name);
     525                 :            :         }
     526   [ -  +  -  + ]:         24 :         SET_SCOPE(scopes, name, FREE);
     527                 :         24 :         ste->ste_free = 1;
     528                 :         24 :         return PySet_Add(free, name) >= 0;
     529                 :            :     }
     530         [ +  + ]:      50897 :     if (flags & DEF_BOUND) {
     531   [ -  +  -  + ]:      34549 :         SET_SCOPE(scopes, name, LOCAL);
     532         [ -  + ]:      34549 :         if (PySet_Add(local, name) < 0)
     533                 :          0 :             return 0;
     534         [ -  + ]:      34549 :         if (PySet_Discard(global, name) < 0)
     535                 :          0 :             return 0;
     536                 :      34549 :         return 1;
     537                 :            :     }
     538                 :            :     /* If an enclosing block has a binding for this name, it
     539                 :            :        is a free variable rather than a global variable.
     540                 :            :        Note that having a non-NULL bound implies that the block
     541                 :            :        is nested.
     542                 :            :     */
     543   [ +  +  +  + ]:      16348 :     if (bound && PySet_Contains(bound, name)) {
     544   [ -  +  -  + ]:        897 :         SET_SCOPE(scopes, name, FREE);
     545                 :        897 :         ste->ste_free = 1;
     546                 :        897 :         return PySet_Add(free, name) >= 0;
     547                 :            :     }
     548                 :            :     /* If a parent has a global statement, then call it global
     549                 :            :        explicit?  It could also be global implicit.
     550                 :            :      */
     551   [ +  -  +  + ]:      15451 :     if (global && PySet_Contains(global, name)) {
     552   [ -  +  -  + ]:        117 :         SET_SCOPE(scopes, name, GLOBAL_IMPLICIT);
     553                 :        117 :         return 1;
     554                 :            :     }
     555         [ +  + ]:      15334 :     if (ste->ste_nested)
     556                 :        709 :         ste->ste_free = 1;
     557   [ -  +  -  + ]:      15334 :     SET_SCOPE(scopes, name, GLOBAL_IMPLICIT);
     558                 :      15334 :     return 1;
     559                 :            : }
     560                 :            : 
     561                 :            : #undef SET_SCOPE
     562                 :            : 
     563                 :            : /* If a name is defined in free and also in locals, then this block
     564                 :            :    provides the binding for the free variable.  The name should be
     565                 :            :    marked CELL in this block and removed from the free list.
     566                 :            : 
     567                 :            :    Note that the current block's free variables are included in free.
     568                 :            :    That's safe because no name can be free and local in the same scope.
     569                 :            : */
     570                 :            : 
     571                 :            : static int
     572                 :       6985 : analyze_cells(PyObject *scopes, PyObject *free)
     573                 :            : {
     574                 :            :     PyObject *name, *v, *v_cell;
     575                 :       6985 :     int success = 0;
     576                 :       6985 :     Py_ssize_t pos = 0;
     577                 :            : 
     578                 :       6985 :     v_cell = PyLong_FromLong(CELL);
     579         [ -  + ]:       6985 :     if (!v_cell)
     580                 :          0 :         return 0;
     581         [ +  + ]:      46129 :     while (PyDict_Next(scopes, &pos, &name, &v)) {
     582                 :            :         long scope;
     583                 :            :         assert(PyLong_Check(v));
     584                 :      39144 :         scope = PyLong_AS_LONG(v);
     585         [ +  + ]:      39144 :         if (scope != LOCAL)
     586                 :      15159 :             continue;
     587         [ +  + ]:      23985 :         if (!PySet_Contains(free, name))
     588                 :      23398 :             continue;
     589                 :            :         /* Replace LOCAL with CELL for this name, and remove
     590                 :            :            from free. It is safe to replace the value of name
     591                 :            :            in the dict, because it will not cause a resize.
     592                 :            :          */
     593         [ -  + ]:        587 :         if (PyDict_SetItem(scopes, name, v_cell) < 0)
     594                 :          0 :             goto error;
     595         [ -  + ]:        587 :         if (PySet_Discard(free, name) < 0)
     596                 :          0 :             goto error;
     597                 :            :     }
     598                 :       6985 :     success = 1;
     599                 :       6985 :  error:
     600                 :       6985 :     Py_DECREF(v_cell);
     601                 :       6985 :     return success;
     602                 :            : }
     603                 :            : 
     604                 :            : static int
     605                 :        733 : drop_class_free(PySTEntryObject *ste, PyObject *free)
     606                 :            : {
     607                 :            :     int res;
     608                 :        733 :     res = PySet_Discard(free, &_Py_ID(__class__));
     609         [ -  + ]:        733 :     if (res < 0)
     610                 :          0 :         return 0;
     611         [ +  + ]:        733 :     if (res)
     612                 :        112 :         ste->ste_needs_class_closure = 1;
     613                 :        733 :     return 1;
     614                 :            : }
     615                 :            : 
     616                 :            : /* Enter the final scope information into the ste_symbols dict.
     617                 :            :  *
     618                 :            :  * All arguments are dicts.  Modifies symbols, others are read-only.
     619                 :            : */
     620                 :            : static int
     621                 :       8037 : update_symbols(PyObject *symbols, PyObject *scopes,
     622                 :            :                PyObject *bound, PyObject *free, int classflag)
     623                 :            : {
     624                 :       8037 :     PyObject *name = NULL, *itr = NULL;
     625                 :       8037 :     PyObject *v = NULL, *v_scope = NULL, *v_new = NULL, *v_free = NULL;
     626                 :       8037 :     Py_ssize_t pos = 0;
     627                 :            : 
     628                 :            :     /* Update scope information for all symbols in this scope */
     629         [ +  + ]:      59117 :     while (PyDict_Next(symbols, &pos, &name, &v)) {
     630                 :            :         long scope, flags;
     631                 :            :         assert(PyLong_Check(v));
     632                 :      51080 :         flags = PyLong_AS_LONG(v);
     633                 :      51080 :         v_scope = PyDict_GetItemWithError(scopes, name);
     634                 :            :         assert(v_scope && PyLong_Check(v_scope));
     635                 :      51080 :         scope = PyLong_AS_LONG(v_scope);
     636                 :      51080 :         flags |= (scope << SCOPE_OFFSET);
     637                 :      51080 :         v_new = PyLong_FromLong(flags);
     638         [ -  + ]:      51080 :         if (!v_new)
     639                 :          0 :             return 0;
     640         [ -  + ]:      51080 :         if (PyDict_SetItem(symbols, name, v_new) < 0) {
     641                 :          0 :             Py_DECREF(v_new);
     642                 :          0 :             return 0;
     643                 :            :         }
     644                 :      51080 :         Py_DECREF(v_new);
     645                 :            :     }
     646                 :            : 
     647                 :            :     /* Record not yet resolved free variables from children (if any) */
     648                 :       8037 :     v_free = PyLong_FromLong(FREE << SCOPE_OFFSET);
     649         [ -  + ]:       8037 :     if (!v_free)
     650                 :          0 :         return 0;
     651                 :            : 
     652                 :       8037 :     itr = PyObject_GetIter(free);
     653         [ -  + ]:       8037 :     if (itr == NULL) {
     654                 :          0 :         Py_DECREF(v_free);
     655                 :          0 :         return 0;
     656                 :            :     }
     657                 :            : 
     658         [ +  + ]:       8062 :     while ((name = PyIter_Next(itr))) {
     659                 :         25 :         v = PyDict_GetItemWithError(symbols, name);
     660                 :            : 
     661                 :            :         /* Handle symbol that already exists in this scope */
     662         [ +  + ]:         25 :         if (v) {
     663                 :            :             /* Handle a free variable in a method of
     664                 :            :                the class that has the same name as a local
     665                 :            :                or global in the class scope.
     666                 :            :             */
     667         [ -  + ]:          8 :             if  (classflag &&
     668         [ #  # ]:          0 :                  PyLong_AS_LONG(v) & (DEF_BOUND | DEF_GLOBAL)) {
     669                 :          0 :                 long flags = PyLong_AS_LONG(v) | DEF_FREE_CLASS;
     670                 :          0 :                 v_new = PyLong_FromLong(flags);
     671         [ #  # ]:          0 :                 if (!v_new) {
     672                 :          0 :                     goto error;
     673                 :            :                 }
     674         [ #  # ]:          0 :                 if (PyDict_SetItem(symbols, name, v_new) < 0) {
     675                 :          0 :                     Py_DECREF(v_new);
     676                 :          0 :                     goto error;
     677                 :            :                 }
     678                 :          0 :                 Py_DECREF(v_new);
     679                 :            :             }
     680                 :            :             /* It's a cell, or already free in this scope */
     681                 :          8 :             Py_DECREF(name);
     682                 :          8 :             continue;
     683                 :            :         }
     684         [ -  + ]:         17 :         else if (PyErr_Occurred()) {
     685                 :          0 :             goto error;
     686                 :            :         }
     687                 :            :         /* Handle global symbol */
     688   [ +  -  -  + ]:         17 :         if (bound && !PySet_Contains(bound, name)) {
     689                 :          0 :             Py_DECREF(name);
     690                 :          0 :             continue;       /* it's a global */
     691                 :            :         }
     692                 :            :         /* Propagate new free symbol up the lexical stack */
     693         [ -  + ]:         17 :         if (PyDict_SetItem(symbols, name, v_free) < 0) {
     694                 :          0 :             goto error;
     695                 :            :         }
     696                 :         17 :         Py_DECREF(name);
     697                 :            :     }
     698                 :       8037 :     Py_DECREF(itr);
     699                 :       8037 :     Py_DECREF(v_free);
     700                 :       8037 :     return 1;
     701                 :          0 : error:
     702                 :          0 :     Py_XDECREF(v_free);
     703                 :          0 :     Py_XDECREF(itr);
     704                 :          0 :     Py_XDECREF(name);
     705                 :          0 :     return 0;
     706                 :            : }
     707                 :            : 
     708                 :            : /* Make final symbol table decisions for block of ste.
     709                 :            : 
     710                 :            :    Arguments:
     711                 :            :    ste -- current symtable entry (input/output)
     712                 :            :    bound -- set of variables bound in enclosing scopes (input).  bound
     713                 :            :        is NULL for module blocks.
     714                 :            :    free -- set of free variables in enclosed scopes (output)
     715                 :            :    globals -- set of declared global variables in enclosing scopes (input)
     716                 :            : 
     717                 :            :    The implementation uses two mutually recursive functions,
     718                 :            :    analyze_block() and analyze_child_block().  analyze_block() is
     719                 :            :    responsible for analyzing the individual names defined in a block.
     720                 :            :    analyze_child_block() prepares temporary namespace dictionaries
     721                 :            :    used to evaluated nested blocks.
     722                 :            : 
     723                 :            :    The two functions exist because a child block should see the name
     724                 :            :    bindings of its enclosing blocks, but those bindings should not
     725                 :            :    propagate back to a parent block.
     726                 :            : */
     727                 :            : 
     728                 :            : static int
     729                 :            : analyze_child_block(PySTEntryObject *entry, PyObject *bound, PyObject *free,
     730                 :            :                     PyObject *global, PyObject* child_free);
     731                 :            : 
     732                 :            : static int
     733                 :       8037 : analyze_block(PySTEntryObject *ste, PyObject *bound, PyObject *free,
     734                 :            :               PyObject *global)
     735                 :            : {
     736                 :       8037 :     PyObject *name, *v, *local = NULL, *scopes = NULL, *newbound = NULL;
     737                 :       8037 :     PyObject *newglobal = NULL, *newfree = NULL, *allfree = NULL;
     738                 :            :     PyObject *temp;
     739                 :       8037 :     int i, success = 0;
     740                 :       8037 :     Py_ssize_t pos = 0;
     741                 :            : 
     742                 :       8037 :     local = PySet_New(NULL);  /* collect new names bound in block */
     743         [ -  + ]:       8037 :     if (!local)
     744                 :          0 :         goto error;
     745                 :       8037 :     scopes = PyDict_New();  /* collect scopes defined for each name */
     746         [ -  + ]:       8037 :     if (!scopes)
     747                 :          0 :         goto error;
     748                 :            : 
     749                 :            :     /* Allocate new global and bound variable dictionaries.  These
     750                 :            :        dictionaries hold the names visible in nested blocks.  For
     751                 :            :        ClassBlocks, the bound and global names are initialized
     752                 :            :        before analyzing names, because class bindings aren't
     753                 :            :        visible in methods.  For other blocks, they are initialized
     754                 :            :        after names are analyzed.
     755                 :            :      */
     756                 :            : 
     757                 :            :     /* TODO(jhylton): Package these dicts in a struct so that we
     758                 :            :        can write reasonable helper functions?
     759                 :            :     */
     760                 :       8037 :     newglobal = PySet_New(NULL);
     761         [ -  + ]:       8037 :     if (!newglobal)
     762                 :          0 :         goto error;
     763                 :       8037 :     newfree = PySet_New(NULL);
     764         [ -  + ]:       8037 :     if (!newfree)
     765                 :          0 :         goto error;
     766                 :       8037 :     newbound = PySet_New(NULL);
     767         [ -  + ]:       8037 :     if (!newbound)
     768                 :          0 :         goto error;
     769                 :            : 
     770                 :            :     /* Class namespace has no effect on names visible in
     771                 :            :        nested functions, so populate the global and bound
     772                 :            :        sets to be passed to child blocks before analyzing
     773                 :            :        this one.
     774                 :            :      */
     775         [ +  + ]:       8037 :     if (ste->ste_type == ClassBlock) {
     776                 :            :         /* Pass down known globals */
     777                 :        733 :         temp = PyNumber_InPlaceOr(newglobal, global);
     778         [ -  + ]:        733 :         if (!temp)
     779                 :          0 :             goto error;
     780                 :        733 :         Py_DECREF(temp);
     781                 :            :         /* Pass down previously bound symbols */
     782         [ +  - ]:        733 :         if (bound) {
     783                 :        733 :             temp = PyNumber_InPlaceOr(newbound, bound);
     784         [ -  + ]:        733 :             if (!temp)
     785                 :          0 :                 goto error;
     786                 :        733 :             Py_DECREF(temp);
     787                 :            :         }
     788                 :            :     }
     789                 :            : 
     790         [ +  + ]:      59117 :     while (PyDict_Next(ste->ste_symbols, &pos, &name, &v)) {
     791                 :      51080 :         long flags = PyLong_AS_LONG(v);
     792         [ -  + ]:      51080 :         if (!analyze_name(ste, scopes, name, flags,
     793                 :            :                           bound, local, free, global))
     794                 :          0 :             goto error;
     795                 :            :     }
     796                 :            : 
     797                 :            :     /* Populate global and bound sets to be passed to children. */
     798         [ +  + ]:       8037 :     if (ste->ste_type != ClassBlock) {
     799                 :            :         /* Add function locals to bound set */
     800         [ +  + ]:       7304 :         if (ste->ste_type == FunctionBlock) {
     801                 :       6985 :             temp = PyNumber_InPlaceOr(newbound, local);
     802         [ -  + ]:       6985 :             if (!temp)
     803                 :          0 :                 goto error;
     804                 :       6985 :             Py_DECREF(temp);
     805                 :            :         }
     806                 :            :         /* Pass down previously bound symbols */
     807         [ +  + ]:       7304 :         if (bound) {
     808                 :       6985 :             temp = PyNumber_InPlaceOr(newbound, bound);
     809         [ -  + ]:       6985 :             if (!temp)
     810                 :          0 :                 goto error;
     811                 :       6985 :             Py_DECREF(temp);
     812                 :            :         }
     813                 :            :         /* Pass down known globals */
     814                 :       7304 :         temp = PyNumber_InPlaceOr(newglobal, global);
     815         [ -  + ]:       7304 :         if (!temp)
     816                 :          0 :             goto error;
     817                 :       7304 :         Py_DECREF(temp);
     818                 :            :     }
     819                 :            :     else {
     820                 :            :         /* Special-case __class__ */
     821         [ -  + ]:        733 :         if (PySet_Add(newbound, &_Py_ID(__class__)) < 0)
     822                 :          0 :             goto error;
     823                 :            :     }
     824                 :            : 
     825                 :            :     /* Recursively call analyze_child_block() on each child block.
     826                 :            : 
     827                 :            :        newbound, newglobal now contain the names visible in
     828                 :            :        nested blocks.  The free variables in the children will
     829                 :            :        be collected in allfree.
     830                 :            :     */
     831                 :       8037 :     allfree = PySet_New(NULL);
     832         [ -  + ]:       8037 :     if (!allfree)
     833                 :          0 :         goto error;
     834         [ +  + ]:      15755 :     for (i = 0; i < PyList_GET_SIZE(ste->ste_children); ++i) {
     835                 :       7718 :         PyObject *c = PyList_GET_ITEM(ste->ste_children, i);
     836                 :            :         PySTEntryObject* entry;
     837                 :            :         assert(c && PySTEntry_Check(c));
     838                 :       7718 :         entry = (PySTEntryObject*)c;
     839         [ -  + ]:       7718 :         if (!analyze_child_block(entry, newbound, newfree, newglobal,
     840                 :            :                                  allfree))
     841                 :          0 :             goto error;
     842                 :            :         /* Check if any children have free variables */
     843   [ +  +  +  + ]:       7718 :         if (entry->ste_free || entry->ste_child_free)
     844                 :       1342 :             ste->ste_child_free = 1;
     845                 :            :     }
     846                 :            : 
     847                 :       8037 :     temp = PyNumber_InPlaceOr(newfree, allfree);
     848         [ -  + ]:       8037 :     if (!temp)
     849                 :          0 :         goto error;
     850                 :       8037 :     Py_DECREF(temp);
     851                 :            : 
     852                 :            :     /* Check if any local variables must be converted to cell variables */
     853   [ +  +  -  + ]:       8037 :     if (ste->ste_type == FunctionBlock && !analyze_cells(scopes, newfree))
     854                 :          0 :         goto error;
     855   [ +  +  -  + ]:       8037 :     else if (ste->ste_type == ClassBlock && !drop_class_free(ste, newfree))
     856                 :          0 :         goto error;
     857                 :            :     /* Records the results of the analysis in the symbol table entry */
     858         [ -  + ]:       8037 :     if (!update_symbols(ste->ste_symbols, scopes, bound, newfree,
     859                 :       8037 :                         ste->ste_type == ClassBlock))
     860                 :          0 :         goto error;
     861                 :            : 
     862                 :       8037 :     temp = PyNumber_InPlaceOr(free, newfree);
     863         [ -  + ]:       8037 :     if (!temp)
     864                 :          0 :         goto error;
     865                 :       8037 :     Py_DECREF(temp);
     866                 :       8037 :     success = 1;
     867                 :       8037 :  error:
     868                 :       8037 :     Py_XDECREF(scopes);
     869                 :       8037 :     Py_XDECREF(local);
     870                 :       8037 :     Py_XDECREF(newbound);
     871                 :       8037 :     Py_XDECREF(newglobal);
     872                 :       8037 :     Py_XDECREF(newfree);
     873                 :       8037 :     Py_XDECREF(allfree);
     874                 :            :     if (!success)
     875                 :            :         assert(PyErr_Occurred());
     876                 :       8037 :     return success;
     877                 :            : }
     878                 :            : 
     879                 :            : static int
     880                 :       7718 : analyze_child_block(PySTEntryObject *entry, PyObject *bound, PyObject *free,
     881                 :            :                     PyObject *global, PyObject* child_free)
     882                 :            : {
     883                 :       7718 :     PyObject *temp_bound = NULL, *temp_global = NULL, *temp_free = NULL;
     884                 :            :     PyObject *temp;
     885                 :            : 
     886                 :            :     /* Copy the bound and global dictionaries.
     887                 :            : 
     888                 :            :        These dictionaries are used by all blocks enclosed by the
     889                 :            :        current block.  The analyze_block() call modifies these
     890                 :            :        dictionaries.
     891                 :            : 
     892                 :            :     */
     893                 :       7718 :     temp_bound = PySet_New(bound);
     894         [ -  + ]:       7718 :     if (!temp_bound)
     895                 :          0 :         goto error;
     896                 :       7718 :     temp_free = PySet_New(free);
     897         [ -  + ]:       7718 :     if (!temp_free)
     898                 :          0 :         goto error;
     899                 :       7718 :     temp_global = PySet_New(global);
     900         [ -  + ]:       7718 :     if (!temp_global)
     901                 :          0 :         goto error;
     902                 :            : 
     903         [ -  + ]:       7718 :     if (!analyze_block(entry, temp_bound, temp_free, temp_global))
     904                 :          0 :         goto error;
     905                 :       7718 :     temp = PyNumber_InPlaceOr(child_free, temp_free);
     906         [ -  + ]:       7718 :     if (!temp)
     907                 :          0 :         goto error;
     908                 :       7718 :     Py_DECREF(temp);
     909                 :       7718 :     Py_DECREF(temp_bound);
     910                 :       7718 :     Py_DECREF(temp_free);
     911                 :       7718 :     Py_DECREF(temp_global);
     912                 :       7718 :     return 1;
     913                 :          0 :  error:
     914                 :          0 :     Py_XDECREF(temp_bound);
     915                 :          0 :     Py_XDECREF(temp_free);
     916                 :          0 :     Py_XDECREF(temp_global);
     917                 :          0 :     return 0;
     918                 :            : }
     919                 :            : 
     920                 :            : static int
     921                 :        319 : symtable_analyze(struct symtable *st)
     922                 :            : {
     923                 :            :     PyObject *free, *global;
     924                 :            :     int r;
     925                 :            : 
     926                 :        319 :     free = PySet_New(NULL);
     927         [ -  + ]:        319 :     if (!free)
     928                 :          0 :         return 0;
     929                 :        319 :     global = PySet_New(NULL);
     930         [ -  + ]:        319 :     if (!global) {
     931                 :          0 :         Py_DECREF(free);
     932                 :          0 :         return 0;
     933                 :            :     }
     934                 :        319 :     r = analyze_block(st->st_top, NULL, free, global);
     935                 :        319 :     Py_DECREF(free);
     936                 :        319 :     Py_DECREF(global);
     937                 :        319 :     return r;
     938                 :            : }
     939                 :            : 
     940                 :            : /* symtable_enter_block() gets a reference via ste_new.
     941                 :            :    This reference is released when the block is exited, via the DECREF
     942                 :            :    in symtable_exit_block().
     943                 :            : */
     944                 :            : 
     945                 :            : static int
     946                 :       8037 : symtable_exit_block(struct symtable *st)
     947                 :            : {
     948                 :            :     Py_ssize_t size;
     949                 :            : 
     950                 :       8037 :     st->st_cur = NULL;
     951                 :       8037 :     size = PyList_GET_SIZE(st->st_stack);
     952         [ +  - ]:       8037 :     if (size) {
     953         [ -  + ]:       8037 :         if (PyList_SetSlice(st->st_stack, size - 1, size, NULL) < 0)
     954                 :          0 :             return 0;
     955         [ +  + ]:       8037 :         if (--size)
     956                 :       7718 :             st->st_cur = (PySTEntryObject *)PyList_GET_ITEM(st->st_stack, size - 1);
     957                 :            :     }
     958                 :       8037 :     return 1;
     959                 :            : }
     960                 :            : 
     961                 :            : static int
     962                 :       8037 : symtable_enter_block(struct symtable *st, identifier name, _Py_block_ty block,
     963                 :            :                      void *ast, int lineno, int col_offset,
     964                 :            :                      int end_lineno, int end_col_offset)
     965                 :            : {
     966                 :       8037 :     PySTEntryObject *prev = NULL, *ste;
     967                 :            : 
     968                 :       8037 :     ste = ste_new(st, name, block, ast, lineno, col_offset, end_lineno, end_col_offset);
     969         [ -  + ]:       8037 :     if (ste == NULL)
     970                 :          0 :         return 0;
     971         [ -  + ]:       8037 :     if (PyList_Append(st->st_stack, (PyObject *)ste) < 0) {
     972                 :          0 :         Py_DECREF(ste);
     973                 :          0 :         return 0;
     974                 :            :     }
     975                 :       8037 :     prev = st->st_cur;
     976                 :            :     /* bpo-37757: For now, disallow *all* assignment expressions in the
     977                 :            :      * outermost iterator expression of a comprehension, even those inside
     978                 :            :      * a nested comprehension or a lambda expression.
     979                 :            :      */
     980         [ +  + ]:       8037 :     if (prev) {
     981                 :       7718 :         ste->ste_comp_iter_expr = prev->ste_comp_iter_expr;
     982                 :            :     }
     983                 :            :     /* The entry is owned by the stack. Borrow it for st_cur. */
     984                 :       8037 :     Py_DECREF(ste);
     985                 :       8037 :     st->st_cur = ste;
     986                 :            : 
     987                 :            :     /* Annotation blocks shouldn't have any affect on the symbol table since in
     988                 :            :      * the compilation stage, they will all be transformed to strings. They are
     989                 :            :      * only created if future 'annotations' feature is activated. */
     990         [ -  + ]:       8037 :     if (block == AnnotationBlock) {
     991                 :          0 :         return 1;
     992                 :            :     }
     993                 :            : 
     994         [ +  + ]:       8037 :     if (block == ModuleBlock)
     995                 :        319 :         st->st_global = st->st_cur->ste_symbols;
     996                 :            : 
     997         [ +  + ]:       8037 :     if (prev) {
     998         [ -  + ]:       7718 :         if (PyList_Append(prev->ste_children, (PyObject *)ste) < 0) {
     999                 :          0 :             return 0;
    1000                 :            :         }
    1001                 :            :     }
    1002                 :       8037 :     return 1;
    1003                 :            : }
    1004                 :            : 
    1005                 :            : static long
    1006                 :        115 : symtable_lookup(struct symtable *st, PyObject *name)
    1007                 :            : {
    1008                 :        115 :     PyObject *mangled = _Py_Mangle(st->st_private, name);
    1009         [ -  + ]:        115 :     if (!mangled)
    1010                 :          0 :         return 0;
    1011                 :        115 :     long ret = _PyST_GetSymbol(st->st_cur, mangled);
    1012                 :        115 :     Py_DECREF(mangled);
    1013                 :        115 :     return ret;
    1014                 :            : }
    1015                 :            : 
    1016                 :            : static int
    1017                 :     124337 : symtable_add_def_helper(struct symtable *st, PyObject *name, int flag, struct _symtable_entry *ste,
    1018                 :            :                         int lineno, int col_offset, int end_lineno, int end_col_offset)
    1019                 :            : {
    1020                 :            :     PyObject *o;
    1021                 :            :     PyObject *dict;
    1022                 :            :     long val;
    1023                 :     124337 :     PyObject *mangled = _Py_Mangle(st->st_private, name);
    1024                 :            : 
    1025                 :            : 
    1026         [ -  + ]:     124337 :     if (!mangled)
    1027                 :          0 :         return 0;
    1028                 :     124337 :     dict = ste->ste_symbols;
    1029         [ +  + ]:     124337 :     if ((o = PyDict_GetItemWithError(dict, mangled))) {
    1030                 :      73264 :         val = PyLong_AS_LONG(o);
    1031   [ -  +  -  - ]:      73264 :         if ((flag & DEF_PARAM) && (val & DEF_PARAM)) {
    1032                 :            :             /* Is it better to use 'mangled' or 'name' here? */
    1033                 :          0 :             PyErr_Format(PyExc_SyntaxError, DUPLICATE_ARGUMENT, name);
    1034                 :          0 :             PyErr_RangedSyntaxLocationObject(st->st_filename,
    1035                 :            :                                              lineno, col_offset + 1,
    1036                 :            :                                              end_lineno, end_col_offset + 1);
    1037                 :          0 :             goto error;
    1038                 :            :         }
    1039                 :      73264 :         val |= flag;
    1040                 :            :     }
    1041         [ -  + ]:      51073 :     else if (PyErr_Occurred()) {
    1042                 :          0 :         goto error;
    1043                 :            :     }
    1044                 :            :     else {
    1045                 :      51073 :         val = flag;
    1046                 :            :     }
    1047         [ +  + ]:     124337 :     if (ste->ste_comp_iter_target) {
    1048                 :            :         /* This name is an iteration variable in a comprehension,
    1049                 :            :          * so check for a binding conflict with any named expressions.
    1050                 :            :          * Otherwise, mark it as an iteration variable so subsequent
    1051                 :            :          * named expressions can check for conflicts.
    1052                 :            :          */
    1053         [ -  + ]:        553 :         if (val & (DEF_GLOBAL | DEF_NONLOCAL)) {
    1054                 :          0 :             PyErr_Format(PyExc_SyntaxError,
    1055                 :            :                 NAMED_EXPR_COMP_INNER_LOOP_CONFLICT, name);
    1056                 :          0 :             PyErr_RangedSyntaxLocationObject(st->st_filename,
    1057                 :            :                                              lineno, col_offset + 1,
    1058                 :            :                                              end_lineno, end_col_offset + 1);
    1059                 :          0 :             goto error;
    1060                 :            :         }
    1061                 :        553 :         val |= DEF_COMP_ITER;
    1062                 :            :     }
    1063                 :     124337 :     o = PyLong_FromLong(val);
    1064         [ -  + ]:     124337 :     if (o == NULL)
    1065                 :          0 :         goto error;
    1066         [ -  + ]:     124337 :     if (PyDict_SetItem(dict, mangled, o) < 0) {
    1067                 :          0 :         Py_DECREF(o);
    1068                 :          0 :         goto error;
    1069                 :            :     }
    1070                 :     124337 :     Py_DECREF(o);
    1071                 :            : 
    1072         [ +  + ]:     124337 :     if (flag & DEF_PARAM) {
    1073         [ -  + ]:      13969 :         if (PyList_Append(ste->ste_varnames, mangled) < 0)
    1074                 :          0 :             goto error;
    1075         [ +  + ]:     110368 :     } else      if (flag & DEF_GLOBAL) {
    1076                 :            :         /* XXX need to update DEF_GLOBAL for other flags too;
    1077                 :            :            perhaps only DEF_FREE_GLOBAL */
    1078                 :         84 :         val = flag;
    1079         [ +  + ]:         84 :         if ((o = PyDict_GetItemWithError(st->st_global, mangled))) {
    1080                 :         77 :             val |= PyLong_AS_LONG(o);
    1081                 :            :         }
    1082         [ -  + ]:          7 :         else if (PyErr_Occurred()) {
    1083                 :          0 :             goto error;
    1084                 :            :         }
    1085                 :         84 :         o = PyLong_FromLong(val);
    1086         [ -  + ]:         84 :         if (o == NULL)
    1087                 :          0 :             goto error;
    1088         [ -  + ]:         84 :         if (PyDict_SetItem(st->st_global, mangled, o) < 0) {
    1089                 :          0 :             Py_DECREF(o);
    1090                 :          0 :             goto error;
    1091                 :            :         }
    1092                 :         84 :         Py_DECREF(o);
    1093                 :            :     }
    1094                 :     124337 :     Py_DECREF(mangled);
    1095                 :     124337 :     return 1;
    1096                 :            : 
    1097                 :          0 : error:
    1098                 :          0 :     Py_DECREF(mangled);
    1099                 :          0 :     return 0;
    1100                 :            : }
    1101                 :            : 
    1102                 :            : static int
    1103                 :     124337 : symtable_add_def(struct symtable *st, PyObject *name, int flag,
    1104                 :            :                  int lineno, int col_offset, int end_lineno, int end_col_offset)
    1105                 :            : {
    1106                 :     124337 :     return symtable_add_def_helper(st, name, flag, st->st_cur,
    1107                 :            :                         lineno, col_offset, end_lineno, end_col_offset);
    1108                 :            : }
    1109                 :            : 
    1110                 :            : /* VISIT, VISIT_SEQ and VIST_SEQ_TAIL take an ASDL type as their second argument.
    1111                 :            :    They use the ASDL name to synthesize the name of the C type and the visit
    1112                 :            :    function.
    1113                 :            : 
    1114                 :            :    VISIT_SEQ_TAIL permits the start of an ASDL sequence to be skipped, which is
    1115                 :            :    useful if the first node in the sequence requires special treatment.
    1116                 :            : 
    1117                 :            :    VISIT_QUIT macro returns the specified value exiting from the function but
    1118                 :            :    first adjusts current recursion counter depth.
    1119                 :            : */
    1120                 :            : 
    1121                 :            : #define VISIT_QUIT(ST, X) \
    1122                 :            :     return --(ST)->recursion_depth,(X)
    1123                 :            : 
    1124                 :            : #define VISIT(ST, TYPE, V) \
    1125                 :            :     if (!symtable_visit_ ## TYPE((ST), (V))) \
    1126                 :            :         VISIT_QUIT((ST), 0);
    1127                 :            : 
    1128                 :            : #define VISIT_SEQ(ST, TYPE, SEQ) { \
    1129                 :            :     int i; \
    1130                 :            :     asdl_ ## TYPE ## _seq *seq = (SEQ); /* avoid variable capture */ \
    1131                 :            :     for (i = 0; i < asdl_seq_LEN(seq); i++) { \
    1132                 :            :         TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
    1133                 :            :         if (!symtable_visit_ ## TYPE((ST), elt)) \
    1134                 :            :             VISIT_QUIT((ST), 0);                 \
    1135                 :            :     } \
    1136                 :            : }
    1137                 :            : 
    1138                 :            : #define VISIT_SEQ_TAIL(ST, TYPE, SEQ, START) { \
    1139                 :            :     int i; \
    1140                 :            :     asdl_ ## TYPE ## _seq *seq = (SEQ); /* avoid variable capture */ \
    1141                 :            :     for (i = (START); i < asdl_seq_LEN(seq); i++) { \
    1142                 :            :         TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
    1143                 :            :         if (!symtable_visit_ ## TYPE((ST), elt)) \
    1144                 :            :             VISIT_QUIT((ST), 0);                 \
    1145                 :            :     } \
    1146                 :            : }
    1147                 :            : 
    1148                 :            : #define VISIT_SEQ_WITH_NULL(ST, TYPE, SEQ) {     \
    1149                 :            :     int i = 0; \
    1150                 :            :     asdl_ ## TYPE ## _seq *seq = (SEQ); /* avoid variable capture */ \
    1151                 :            :     for (i = 0; i < asdl_seq_LEN(seq); i++) { \
    1152                 :            :         TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
    1153                 :            :         if (!elt) continue; /* can be NULL */ \
    1154                 :            :         if (!symtable_visit_ ## TYPE((ST), elt)) \
    1155                 :            :             VISIT_QUIT((ST), 0);             \
    1156                 :            :     } \
    1157                 :            : }
    1158                 :            : 
    1159                 :            : static int
    1160                 :        108 : symtable_record_directive(struct symtable *st, identifier name, int lineno,
    1161                 :            :                           int col_offset, int end_lineno, int end_col_offset)
    1162                 :            : {
    1163                 :            :     PyObject *data, *mangled;
    1164                 :            :     int res;
    1165         [ +  + ]:        108 :     if (!st->st_cur->ste_directives) {
    1166                 :         84 :         st->st_cur->ste_directives = PyList_New(0);
    1167         [ -  + ]:         84 :         if (!st->st_cur->ste_directives)
    1168                 :          0 :             return 0;
    1169                 :            :     }
    1170                 :        108 :     mangled = _Py_Mangle(st->st_private, name);
    1171         [ -  + ]:        108 :     if (!mangled)
    1172                 :          0 :         return 0;
    1173                 :        108 :     data = Py_BuildValue("(Niiii)", mangled, lineno, col_offset, end_lineno, end_col_offset);
    1174         [ -  + ]:        108 :     if (!data)
    1175                 :          0 :         return 0;
    1176                 :        108 :     res = PyList_Append(st->st_cur->ste_directives, data);
    1177                 :        108 :     Py_DECREF(data);
    1178                 :        108 :     return res == 0;
    1179                 :            : }
    1180                 :            : 
    1181                 :            : 
    1182                 :            : static int
    1183                 :      58316 : symtable_visit_stmt(struct symtable *st, stmt_ty s)
    1184                 :            : {
    1185         [ -  + ]:      58316 :     if (++st->recursion_depth > st->recursion_limit) {
    1186                 :          0 :         PyErr_SetString(PyExc_RecursionError,
    1187                 :            :                         "maximum recursion depth exceeded during compilation");
    1188                 :          0 :         VISIT_QUIT(st, 0);
    1189                 :            :     }
    1190   [ +  +  +  +  :      58316 :     switch (s->kind) {
          +  +  +  +  +  
          +  +  +  +  -  
          +  +  +  +  +  
          +  +  +  +  +  
                   -  - ]
    1191                 :       6243 :     case FunctionDef_kind:
    1192         [ -  + ]:       6243 :         if (!symtable_add_def(st, s->v.FunctionDef.name, DEF_LOCAL, LOCATION(s)))
    1193                 :          0 :             VISIT_QUIT(st, 0);
    1194         [ +  - ]:       6243 :         if (s->v.FunctionDef.args->defaults)
    1195   [ -  +  +  -  :       7962 :             VISIT_SEQ(st, expr, s->v.FunctionDef.args->defaults);
                   +  + ]
    1196         [ +  - ]:       6243 :         if (s->v.FunctionDef.args->kw_defaults)
    1197   [ +  +  -  +  :       6669 :             VISIT_SEQ_WITH_NULL(st, expr, s->v.FunctionDef.args->kw_defaults);
             +  -  +  + ]
    1198         [ -  + ]:       6243 :         if (!symtable_visit_annotations(st, s, s->v.FunctionDef.args,
    1199                 :            :                                         s->v.FunctionDef.returns))
    1200                 :          0 :             VISIT_QUIT(st, 0);
    1201         [ +  + ]:       6243 :         if (s->v.FunctionDef.decorator_list)
    1202   [ -  +  +  -  :       1160 :             VISIT_SEQ(st, expr, s->v.FunctionDef.decorator_list);
                   +  + ]
    1203         [ -  + ]:       6243 :         if (!symtable_enter_block(st, s->v.FunctionDef.name,
    1204                 :            :                                   FunctionBlock, (void *)s,
    1205                 :            :                                   LOCATION(s)))
    1206                 :          0 :             VISIT_QUIT(st, 0);
    1207         [ -  + ]:       6243 :         VISIT(st, arguments, s->v.FunctionDef.args);
    1208   [ -  +  +  -  :      27569 :         VISIT_SEQ(st, stmt, s->v.FunctionDef.body);
                   +  + ]
    1209         [ -  + ]:       6243 :         if (!symtable_exit_block(st))
    1210                 :          0 :             VISIT_QUIT(st, 0);
    1211                 :       6243 :         break;
    1212                 :        733 :     case ClassDef_kind: {
    1213                 :            :         PyObject *tmp;
    1214         [ -  + ]:        733 :         if (!symtable_add_def(st, s->v.ClassDef.name, DEF_LOCAL, LOCATION(s)))
    1215                 :          0 :             VISIT_QUIT(st, 0);
    1216   [ -  +  +  +  :       1337 :         VISIT_SEQ(st, expr, s->v.ClassDef.bases);
                   +  + ]
    1217   [ -  +  +  +  :        789 :         VISIT_SEQ(st, keyword, s->v.ClassDef.keywords);
                   +  + ]
    1218         [ +  + ]:        733 :         if (s->v.ClassDef.decorator_list)
    1219   [ -  +  +  -  :         35 :             VISIT_SEQ(st, expr, s->v.ClassDef.decorator_list);
                   +  + ]
    1220         [ -  + ]:        733 :         if (!symtable_enter_block(st, s->v.ClassDef.name, ClassBlock,
    1221                 :            :                                   (void *)s, s->lineno, s->col_offset,
    1222                 :            :                                   s->end_lineno, s->end_col_offset))
    1223                 :          0 :             VISIT_QUIT(st, 0);
    1224                 :        733 :         tmp = st->st_private;
    1225                 :        733 :         st->st_private = s->v.ClassDef.name;
    1226   [ -  +  +  -  :       6162 :         VISIT_SEQ(st, stmt, s->v.ClassDef.body);
                   +  + ]
    1227                 :        733 :         st->st_private = tmp;
    1228         [ -  + ]:        733 :         if (!symtable_exit_block(st))
    1229                 :          0 :             VISIT_QUIT(st, 0);
    1230                 :        733 :         break;
    1231                 :            :     }
    1232                 :       5841 :     case Return_kind:
    1233         [ +  + ]:       5841 :         if (s->v.Return.value) {
    1234         [ -  + ]:       5514 :             VISIT(st, expr, s->v.Return.value);
    1235                 :       5514 :             st->st_cur->ste_returns_value = 1;
    1236                 :            :         }
    1237                 :       5841 :         break;
    1238                 :        192 :     case Delete_kind:
    1239   [ -  +  +  -  :        417 :         VISIT_SEQ(st, expr, s->v.Delete.targets);
                   +  + ]
    1240                 :        192 :         break;
    1241                 :      16574 :     case Assign_kind:
    1242   [ -  +  +  -  :      33303 :         VISIT_SEQ(st, expr, s->v.Assign.targets);
                   +  + ]
    1243         [ -  + ]:      16574 :         VISIT(st, expr, s->v.Assign.value);
    1244                 :      16574 :         break;
    1245                 :         17 :     case AnnAssign_kind:
    1246         [ +  + ]:         17 :         if (s->v.AnnAssign.target->kind == Name_kind) {
    1247                 :          7 :             expr_ty e_name = s->v.AnnAssign.target;
    1248                 :          7 :             long cur = symtable_lookup(st, e_name->v.Name.id);
    1249         [ -  + ]:          7 :             if (cur < 0) {
    1250                 :          0 :                 VISIT_QUIT(st, 0);
    1251                 :            :             }
    1252         [ -  + ]:          7 :             if ((cur & (DEF_GLOBAL | DEF_NONLOCAL))
    1253         [ #  # ]:          0 :                 && (st->st_cur->ste_symbols != st->st_global)
    1254         [ #  # ]:          0 :                 && s->v.AnnAssign.simple) {
    1255                 :          0 :                 PyErr_Format(PyExc_SyntaxError,
    1256         [ #  # ]:          0 :                              cur & DEF_GLOBAL ? GLOBAL_ANNOT : NONLOCAL_ANNOT,
    1257                 :            :                              e_name->v.Name.id);
    1258                 :          0 :                 PyErr_RangedSyntaxLocationObject(st->st_filename,
    1259                 :            :                                                  s->lineno,
    1260                 :          0 :                                                  s->col_offset + 1,
    1261                 :            :                                                  s->end_lineno,
    1262                 :          0 :                                                  s->end_col_offset + 1);
    1263                 :          0 :                 VISIT_QUIT(st, 0);
    1264                 :            :             }
    1265   [ +  -  -  + ]:         14 :             if (s->v.AnnAssign.simple &&
    1266                 :          7 :                 !symtable_add_def(st, e_name->v.Name.id,
    1267                 :            :                                   DEF_ANNOT | DEF_LOCAL, LOCATION(e_name))) {
    1268                 :          0 :                 VISIT_QUIT(st, 0);
    1269                 :            :             }
    1270                 :            :             else {
    1271         [ +  + ]:          7 :                 if (s->v.AnnAssign.value
    1272         [ -  + ]:          5 :                     && !symtable_add_def(st, e_name->v.Name.id, DEF_LOCAL, LOCATION(e_name))) {
    1273                 :          0 :                     VISIT_QUIT(st, 0);
    1274                 :            :                 }
    1275                 :            :             }
    1276                 :            :         }
    1277                 :            :         else {
    1278         [ -  + ]:         10 :             VISIT(st, expr, s->v.AnnAssign.target);
    1279                 :            :         }
    1280         [ -  + ]:         17 :         if (!symtable_visit_annotation(st, s->v.AnnAssign.annotation)) {
    1281                 :          0 :             VISIT_QUIT(st, 0);
    1282                 :            :         }
    1283                 :            : 
    1284         [ +  + ]:         17 :         if (s->v.AnnAssign.value) {
    1285         [ -  + ]:         15 :             VISIT(st, expr, s->v.AnnAssign.value);
    1286                 :            :         }
    1287                 :         17 :         break;
    1288                 :        715 :     case AugAssign_kind:
    1289         [ -  + ]:        715 :         VISIT(st, expr, s->v.AugAssign.target);
    1290         [ -  + ]:        715 :         VISIT(st, expr, s->v.AugAssign.value);
    1291                 :        715 :         break;
    1292                 :       1222 :     case For_kind:
    1293         [ -  + ]:       1222 :         VISIT(st, expr, s->v.For.target);
    1294         [ -  + ]:       1222 :         VISIT(st, expr, s->v.For.iter);
    1295   [ -  +  +  -  :       3566 :         VISIT_SEQ(st, stmt, s->v.For.body);
                   +  + ]
    1296         [ +  + ]:       1222 :         if (s->v.For.orelse)
    1297   [ -  +  +  -  :        107 :             VISIT_SEQ(st, stmt, s->v.For.orelse);
                   +  + ]
    1298                 :       1222 :         break;
    1299                 :        302 :     case While_kind:
    1300         [ -  + ]:        302 :         VISIT(st, expr, s->v.While.test);
    1301   [ -  +  +  -  :       1208 :         VISIT_SEQ(st, stmt, s->v.While.body);
                   +  + ]
    1302         [ +  + ]:        302 :         if (s->v.While.orelse)
    1303   [ -  +  +  -  :         10 :             VISIT_SEQ(st, stmt, s->v.While.orelse);
                   +  + ]
    1304                 :        302 :         break;
    1305                 :       8830 :     case If_kind:
    1306                 :            :         /* XXX if 0: and lookup_yield() hacks */
    1307         [ -  + ]:       8830 :         VISIT(st, expr, s->v.If.test);
    1308   [ -  +  +  -  :      21926 :         VISIT_SEQ(st, stmt, s->v.If.body);
                   +  + ]
    1309         [ +  + ]:       8830 :         if (s->v.If.orelse)
    1310   [ -  +  +  -  :       5601 :             VISIT_SEQ(st, stmt, s->v.If.orelse);
                   +  + ]
    1311                 :       8830 :         break;
    1312                 :          4 :     case Match_kind:
    1313         [ -  + ]:          4 :         VISIT(st, expr, s->v.Match.subject);
    1314   [ -  +  +  -  :         16 :         VISIT_SEQ(st, match_case, s->v.Match.cases);
                   +  + ]
    1315                 :          4 :         break;
    1316                 :       1931 :     case Raise_kind:
    1317         [ +  + ]:       1931 :         if (s->v.Raise.exc) {
    1318         [ -  + ]:       1732 :             VISIT(st, expr, s->v.Raise.exc);
    1319         [ +  + ]:       1732 :             if (s->v.Raise.cause) {
    1320         [ -  + ]:        102 :                 VISIT(st, expr, s->v.Raise.cause);
    1321                 :            :             }
    1322                 :            :         }
    1323                 :       1931 :         break;
    1324                 :       1455 :     case Try_kind:
    1325   [ -  +  +  -  :       3528 :         VISIT_SEQ(st, stmt, s->v.Try.body);
                   +  + ]
    1326   [ -  +  +  +  :       1841 :         VISIT_SEQ(st, stmt, s->v.Try.orelse);
                   +  + ]
    1327   [ -  +  +  +  :       2886 :         VISIT_SEQ(st, excepthandler, s->v.Try.handlers);
                   +  + ]
    1328   [ -  +  +  +  :       1715 :         VISIT_SEQ(st, stmt, s->v.Try.finalbody);
                   +  + ]
    1329                 :       1455 :         break;
    1330                 :          0 :     case TryStar_kind:
    1331   [ #  #  #  #  :          0 :         VISIT_SEQ(st, stmt, s->v.TryStar.body);
                   #  # ]
    1332   [ #  #  #  #  :          0 :         VISIT_SEQ(st, stmt, s->v.TryStar.orelse);
                   #  # ]
    1333   [ #  #  #  #  :          0 :         VISIT_SEQ(st, excepthandler, s->v.TryStar.handlers);
                   #  # ]
    1334   [ #  #  #  #  :          0 :         VISIT_SEQ(st, stmt, s->v.TryStar.finalbody);
                   #  # ]
    1335                 :          0 :         break;
    1336                 :        239 :     case Assert_kind:
    1337         [ -  + ]:        239 :         VISIT(st, expr, s->v.Assert.test);
    1338         [ +  + ]:        239 :         if (s->v.Assert.msg)
    1339         [ -  + ]:         71 :             VISIT(st, expr, s->v.Assert.msg);
    1340                 :        239 :         break;
    1341                 :        896 :     case Import_kind:
    1342   [ -  +  +  -  :       1813 :         VISIT_SEQ(st, alias, s->v.Import.names);
                   +  + ]
    1343                 :        896 :         break;
    1344                 :        524 :     case ImportFrom_kind:
    1345   [ -  +  +  -  :       1347 :         VISIT_SEQ(st, alias, s->v.ImportFrom.names);
                   +  + ]
    1346                 :        524 :         break;
    1347                 :         70 :     case Global_kind: {
    1348                 :            :         int i;
    1349                 :         70 :         asdl_identifier_seq *seq = s->v.Global.names;
    1350   [ +  -  +  + ]:        154 :         for (i = 0; i < asdl_seq_LEN(seq); i++) {
    1351                 :         84 :             identifier name = (identifier)asdl_seq_GET(seq, i);
    1352                 :         84 :             long cur = symtable_lookup(st, name);
    1353         [ -  + ]:         84 :             if (cur < 0)
    1354                 :          0 :                 VISIT_QUIT(st, 0);
    1355         [ -  + ]:         84 :             if (cur & (DEF_PARAM | DEF_LOCAL | USE | DEF_ANNOT)) {
    1356                 :            :                 const char* msg;
    1357         [ #  # ]:          0 :                 if (cur & DEF_PARAM) {
    1358                 :          0 :                     msg = GLOBAL_PARAM;
    1359         [ #  # ]:          0 :                 } else if (cur & USE) {
    1360                 :          0 :                     msg = GLOBAL_AFTER_USE;
    1361         [ #  # ]:          0 :                 } else if (cur & DEF_ANNOT) {
    1362                 :          0 :                     msg = GLOBAL_ANNOT;
    1363                 :            :                 } else {  /* DEF_LOCAL */
    1364                 :          0 :                     msg = GLOBAL_AFTER_ASSIGN;
    1365                 :            :                 }
    1366                 :          0 :                 PyErr_Format(PyExc_SyntaxError,
    1367                 :            :                              msg, name);
    1368                 :          0 :                 PyErr_RangedSyntaxLocationObject(st->st_filename,
    1369                 :            :                                                  s->lineno,
    1370                 :          0 :                                                  s->col_offset + 1,
    1371                 :            :                                                  s->end_lineno,
    1372                 :          0 :                                                  s->end_col_offset + 1);
    1373                 :          0 :                 VISIT_QUIT(st, 0);
    1374                 :            :             }
    1375         [ -  + ]:         84 :             if (!symtable_add_def(st, name, DEF_GLOBAL, LOCATION(s)))
    1376                 :          0 :                 VISIT_QUIT(st, 0);
    1377         [ -  + ]:         84 :             if (!symtable_record_directive(st, name, s->lineno, s->col_offset,
    1378                 :            :                                            s->end_lineno, s->end_col_offset))
    1379                 :          0 :                 VISIT_QUIT(st, 0);
    1380                 :            :         }
    1381                 :         70 :         break;
    1382                 :            :     }
    1383                 :         17 :     case Nonlocal_kind: {
    1384                 :            :         int i;
    1385                 :         17 :         asdl_identifier_seq *seq = s->v.Nonlocal.names;
    1386   [ +  -  +  + ]:         41 :         for (i = 0; i < asdl_seq_LEN(seq); i++) {
    1387                 :         24 :             identifier name = (identifier)asdl_seq_GET(seq, i);
    1388                 :         24 :             long cur = symtable_lookup(st, name);
    1389         [ -  + ]:         24 :             if (cur < 0)
    1390                 :          0 :                 VISIT_QUIT(st, 0);
    1391         [ -  + ]:         24 :             if (cur & (DEF_PARAM | DEF_LOCAL | USE | DEF_ANNOT)) {
    1392                 :            :                 const char* msg;
    1393         [ #  # ]:          0 :                 if (cur & DEF_PARAM) {
    1394                 :          0 :                     msg = NONLOCAL_PARAM;
    1395         [ #  # ]:          0 :                 } else if (cur & USE) {
    1396                 :          0 :                     msg = NONLOCAL_AFTER_USE;
    1397         [ #  # ]:          0 :                 } else if (cur & DEF_ANNOT) {
    1398                 :          0 :                     msg = NONLOCAL_ANNOT;
    1399                 :            :                 } else {  /* DEF_LOCAL */
    1400                 :          0 :                     msg = NONLOCAL_AFTER_ASSIGN;
    1401                 :            :                 }
    1402                 :          0 :                 PyErr_Format(PyExc_SyntaxError, msg, name);
    1403                 :          0 :                 PyErr_RangedSyntaxLocationObject(st->st_filename,
    1404                 :            :                                                  s->lineno,
    1405                 :          0 :                                                  s->col_offset + 1,
    1406                 :            :                                                  s->end_lineno,
    1407                 :          0 :                                                  s->end_col_offset + 1);
    1408                 :          0 :                 VISIT_QUIT(st, 0);
    1409                 :            :             }
    1410         [ -  + ]:         24 :             if (!symtable_add_def(st, name, DEF_NONLOCAL, LOCATION(s)))
    1411                 :          0 :                 VISIT_QUIT(st, 0);
    1412         [ -  + ]:         24 :             if (!symtable_record_directive(st, name, s->lineno, s->col_offset,
    1413                 :            :                                            s->end_lineno, s->end_col_offset))
    1414                 :          0 :                 VISIT_QUIT(st, 0);
    1415                 :            :         }
    1416                 :         17 :         break;
    1417                 :            :     }
    1418                 :      10972 :     case Expr_kind:
    1419         [ -  + ]:      10972 :         VISIT(st, expr, s->v.Expr.value);
    1420                 :      10972 :         break;
    1421                 :        998 :     case Pass_kind:
    1422                 :            :     case Break_kind:
    1423                 :            :     case Continue_kind:
    1424                 :            :         /* nothing to do here */
    1425                 :        998 :         break;
    1426                 :        378 :     case With_kind:
    1427   [ -  +  +  -  :        761 :         VISIT_SEQ(st, withitem, s->v.With.items);
                   +  + ]
    1428   [ -  +  +  -  :       1129 :         VISIT_SEQ(st, stmt, s->v.With.body);
                   +  + ]
    1429                 :        378 :         break;
    1430                 :        158 :     case AsyncFunctionDef_kind:
    1431         [ -  + ]:        158 :         if (!symtable_add_def(st, s->v.AsyncFunctionDef.name, DEF_LOCAL, LOCATION(s)))
    1432                 :          0 :             VISIT_QUIT(st, 0);
    1433         [ +  - ]:        158 :         if (s->v.AsyncFunctionDef.args->defaults)
    1434   [ -  +  +  -  :        215 :             VISIT_SEQ(st, expr, s->v.AsyncFunctionDef.args->defaults);
                   +  + ]
    1435         [ +  - ]:        158 :         if (s->v.AsyncFunctionDef.args->kw_defaults)
    1436   [ +  +  -  +  :        305 :             VISIT_SEQ_WITH_NULL(st, expr,
             +  -  +  + ]
    1437                 :            :                                 s->v.AsyncFunctionDef.args->kw_defaults);
    1438         [ -  + ]:        158 :         if (!symtable_visit_annotations(st, s, s->v.AsyncFunctionDef.args,
    1439                 :            :                                         s->v.AsyncFunctionDef.returns))
    1440                 :          0 :             VISIT_QUIT(st, 0);
    1441         [ +  + ]:        158 :         if (s->v.AsyncFunctionDef.decorator_list)
    1442   [ -  +  +  -  :         16 :             VISIT_SEQ(st, expr, s->v.AsyncFunctionDef.decorator_list);
                   +  + ]
    1443         [ -  + ]:        158 :         if (!symtable_enter_block(st, s->v.AsyncFunctionDef.name,
    1444                 :            :                                   FunctionBlock, (void *)s,
    1445                 :            :                                   s->lineno, s->col_offset,
    1446                 :            :                                   s->end_lineno, s->end_col_offset))
    1447                 :          0 :             VISIT_QUIT(st, 0);
    1448                 :        158 :         st->st_cur->ste_coroutine = 1;
    1449         [ -  + ]:        158 :         VISIT(st, arguments, s->v.AsyncFunctionDef.args);
    1450   [ -  +  +  -  :        799 :         VISIT_SEQ(st, stmt, s->v.AsyncFunctionDef.body);
                   +  + ]
    1451         [ -  + ]:        158 :         if (!symtable_exit_block(st))
    1452                 :          0 :             VISIT_QUIT(st, 0);
    1453                 :        158 :         break;
    1454                 :          5 :     case AsyncWith_kind:
    1455   [ -  +  +  -  :         10 :         VISIT_SEQ(st, withitem, s->v.AsyncWith.items);
                   +  + ]
    1456   [ -  +  +  -  :         13 :         VISIT_SEQ(st, stmt, s->v.AsyncWith.body);
                   +  + ]
    1457                 :          5 :         break;
    1458                 :          0 :     case AsyncFor_kind:
    1459         [ #  # ]:          0 :         VISIT(st, expr, s->v.AsyncFor.target);
    1460         [ #  # ]:          0 :         VISIT(st, expr, s->v.AsyncFor.iter);
    1461   [ #  #  #  #  :          0 :         VISIT_SEQ(st, stmt, s->v.AsyncFor.body);
                   #  # ]
    1462         [ #  # ]:          0 :         if (s->v.AsyncFor.orelse)
    1463   [ #  #  #  #  :          0 :             VISIT_SEQ(st, stmt, s->v.AsyncFor.orelse);
                   #  # ]
    1464                 :          0 :         break;
    1465                 :            :     }
    1466                 :      58316 :     VISIT_QUIT(st, 1);
    1467                 :            : }
    1468                 :            : 
    1469                 :            : static int
    1470                 :          0 : symtable_extend_namedexpr_scope(struct symtable *st, expr_ty e)
    1471                 :            : {
    1472                 :            :     assert(st->st_stack);
    1473                 :            :     assert(e->kind == Name_kind);
    1474                 :            : 
    1475                 :          0 :     PyObject *target_name = e->v.Name.id;
    1476                 :            :     Py_ssize_t i, size;
    1477                 :            :     struct _symtable_entry *ste;
    1478                 :          0 :     size = PyList_GET_SIZE(st->st_stack);
    1479                 :            :     assert(size);
    1480                 :            : 
    1481                 :            :     /* Iterate over the stack in reverse and add to the nearest adequate scope */
    1482         [ #  # ]:          0 :     for (i = size - 1; i >= 0; i--) {
    1483                 :          0 :         ste = (struct _symtable_entry *) PyList_GET_ITEM(st->st_stack, i);
    1484                 :            : 
    1485                 :            :         /* If we find a comprehension scope, check for a target
    1486                 :            :          * binding conflict with iteration variables, otherwise skip it
    1487                 :            :          */
    1488         [ #  # ]:          0 :         if (ste->ste_comprehension) {
    1489                 :          0 :             long target_in_scope = _PyST_GetSymbol(ste, target_name);
    1490         [ #  # ]:          0 :             if ((target_in_scope & DEF_COMP_ITER) &&
    1491         [ #  # ]:          0 :                 (target_in_scope & DEF_LOCAL)) {
    1492                 :          0 :                 PyErr_Format(PyExc_SyntaxError, NAMED_EXPR_COMP_CONFLICT, target_name);
    1493                 :          0 :                 PyErr_RangedSyntaxLocationObject(st->st_filename,
    1494                 :            :                                                   e->lineno,
    1495                 :          0 :                                                   e->col_offset + 1,
    1496                 :            :                                                   e->end_lineno,
    1497                 :          0 :                                                   e->end_col_offset + 1);
    1498                 :          0 :                 VISIT_QUIT(st, 0);
    1499                 :            :             }
    1500                 :          0 :             continue;
    1501                 :            :         }
    1502                 :            : 
    1503                 :            :         /* If we find a FunctionBlock entry, add as GLOBAL/LOCAL or NONLOCAL/LOCAL */
    1504         [ #  # ]:          0 :         if (ste->ste_type == FunctionBlock) {
    1505                 :          0 :             long target_in_scope = _PyST_GetSymbol(ste, target_name);
    1506         [ #  # ]:          0 :             if (target_in_scope & DEF_GLOBAL) {
    1507         [ #  # ]:          0 :                 if (!symtable_add_def(st, target_name, DEF_GLOBAL, LOCATION(e)))
    1508                 :          0 :                     VISIT_QUIT(st, 0);
    1509                 :            :             } else {
    1510         [ #  # ]:          0 :                 if (!symtable_add_def(st, target_name, DEF_NONLOCAL, LOCATION(e)))
    1511                 :          0 :                     VISIT_QUIT(st, 0);
    1512                 :            :             }
    1513         [ #  # ]:          0 :             if (!symtable_record_directive(st, target_name, LOCATION(e)))
    1514                 :          0 :                 VISIT_QUIT(st, 0);
    1515                 :            : 
    1516                 :          0 :             return symtable_add_def_helper(st, target_name, DEF_LOCAL, ste, LOCATION(e));
    1517                 :            :         }
    1518                 :            :         /* If we find a ModuleBlock entry, add as GLOBAL */
    1519         [ #  # ]:          0 :         if (ste->ste_type == ModuleBlock) {
    1520         [ #  # ]:          0 :             if (!symtable_add_def(st, target_name, DEF_GLOBAL, LOCATION(e)))
    1521                 :          0 :                 VISIT_QUIT(st, 0);
    1522         [ #  # ]:          0 :             if (!symtable_record_directive(st, target_name, LOCATION(e)))
    1523                 :          0 :                 VISIT_QUIT(st, 0);
    1524                 :            : 
    1525                 :          0 :             return symtable_add_def_helper(st, target_name, DEF_GLOBAL, ste, LOCATION(e));
    1526                 :            :         }
    1527                 :            :         /* Disallow usage in ClassBlock */
    1528         [ #  # ]:          0 :         if (ste->ste_type == ClassBlock) {
    1529                 :          0 :             PyErr_Format(PyExc_SyntaxError, NAMED_EXPR_COMP_IN_CLASS);
    1530                 :          0 :             PyErr_RangedSyntaxLocationObject(st->st_filename,
    1531                 :            :                                               e->lineno,
    1532                 :          0 :                                               e->col_offset + 1,
    1533                 :            :                                               e->end_lineno,
    1534                 :          0 :                                               e->end_col_offset + 1);
    1535                 :          0 :             VISIT_QUIT(st, 0);
    1536                 :            :         }
    1537                 :            :     }
    1538                 :            : 
    1539                 :            :     /* We should always find either a FunctionBlock, ModuleBlock or ClassBlock
    1540                 :            :        and should never fall to this case
    1541                 :            :     */
    1542                 :          0 :     Py_UNREACHABLE();
    1543                 :            :     return 0;
    1544                 :            : }
    1545                 :            : 
    1546                 :            : static int
    1547                 :         23 : symtable_handle_namedexpr(struct symtable *st, expr_ty e)
    1548                 :            : {
    1549         [ -  + ]:         23 :     if (st->st_cur->ste_comp_iter_expr > 0) {
    1550                 :            :         /* Assignment isn't allowed in a comprehension iterable expression */
    1551                 :          0 :         PyErr_Format(PyExc_SyntaxError, NAMED_EXPR_COMP_ITER_EXPR);
    1552                 :          0 :         PyErr_RangedSyntaxLocationObject(st->st_filename,
    1553                 :            :                                           e->lineno,
    1554                 :          0 :                                           e->col_offset + 1,
    1555                 :            :                                           e->end_lineno,
    1556                 :          0 :                                           e->end_col_offset + 1);
    1557                 :          0 :         return 0;
    1558                 :            :     }
    1559         [ -  + ]:         23 :     if (st->st_cur->ste_comprehension) {
    1560                 :            :         /* Inside a comprehension body, so find the right target scope */
    1561         [ #  # ]:          0 :         if (!symtable_extend_namedexpr_scope(st, e->v.NamedExpr.target))
    1562                 :          0 :             return 0;
    1563                 :            :     }
    1564         [ -  + ]:         23 :     VISIT(st, expr, e->v.NamedExpr.value);
    1565         [ -  + ]:         23 :     VISIT(st, expr, e->v.NamedExpr.target);
    1566                 :         23 :     return 1;
    1567                 :            : }
    1568                 :            : 
    1569                 :            : static int
    1570                 :     220307 : symtable_visit_expr(struct symtable *st, expr_ty e)
    1571                 :            : {
    1572         [ -  + ]:     220307 :     if (++st->recursion_depth > st->recursion_limit) {
    1573                 :          0 :         PyErr_SetString(PyExc_RecursionError,
    1574                 :            :                         "maximum recursion depth exceeded during compilation");
    1575                 :          0 :         VISIT_QUIT(st, 0);
    1576                 :            :     }
    1577   [ +  +  +  +  :     220307 :     switch (e->kind) {
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
             +  +  +  - ]
    1578                 :         23 :     case NamedExpr_kind:
    1579         [ -  + ]:         23 :         if (!symtable_raise_if_annotation_block(st, "named expression", e)) {
    1580                 :          0 :             VISIT_QUIT(st, 0);
    1581                 :            :         }
    1582         [ -  + ]:         23 :         if(!symtable_handle_namedexpr(st, e))
    1583                 :          0 :             VISIT_QUIT(st, 0);
    1584                 :         23 :         break;
    1585                 :       1755 :     case BoolOp_kind:
    1586   [ -  +  +  -  :       5525 :         VISIT_SEQ(st, expr, e->v.BoolOp.values);
                   +  + ]
    1587                 :       1755 :         break;
    1588                 :       3503 :     case BinOp_kind:
    1589         [ -  + ]:       3503 :         VISIT(st, expr, e->v.BinOp.left);
    1590         [ -  + ]:       3503 :         VISIT(st, expr, e->v.BinOp.right);
    1591                 :       3503 :         break;
    1592                 :       1788 :     case UnaryOp_kind:
    1593         [ -  + ]:       1788 :         VISIT(st, expr, e->v.UnaryOp.operand);
    1594                 :       1788 :         break;
    1595                 :        135 :     case Lambda_kind: {
    1596         [ +  - ]:        135 :         if (e->v.Lambda.args->defaults)
    1597   [ -  -  +  -  :        135 :             VISIT_SEQ(st, expr, e->v.Lambda.args->defaults);
                   -  + ]
    1598         [ +  - ]:        135 :         if (e->v.Lambda.args->kw_defaults)
    1599   [ -  -  -  -  :        135 :             VISIT_SEQ_WITH_NULL(st, expr, e->v.Lambda.args->kw_defaults);
             +  -  -  + ]
    1600         [ -  + ]:        135 :         if (!symtable_enter_block(st, &_Py_ID(lambda),
    1601                 :            :                                   FunctionBlock, (void *)e,
    1602                 :            :                                   e->lineno, e->col_offset,
    1603                 :            :                                   e->end_lineno, e->end_col_offset))
    1604                 :          0 :             VISIT_QUIT(st, 0);
    1605         [ -  + ]:        135 :         VISIT(st, arguments, e->v.Lambda.args);
    1606         [ -  + ]:        135 :         VISIT(st, expr, e->v.Lambda.body);
    1607         [ -  + ]:        135 :         if (!symtable_exit_block(st))
    1608                 :          0 :             VISIT_QUIT(st, 0);
    1609                 :        135 :         break;
    1610                 :            :     }
    1611                 :        233 :     case IfExp_kind:
    1612         [ -  + ]:        233 :         VISIT(st, expr, e->v.IfExp.test);
    1613         [ -  + ]:        233 :         VISIT(st, expr, e->v.IfExp.body);
    1614         [ -  + ]:        233 :         VISIT(st, expr, e->v.IfExp.orelse);
    1615                 :        233 :         break;
    1616                 :        397 :     case Dict_kind:
    1617   [ +  +  -  +  :       3297 :         VISIT_SEQ_WITH_NULL(st, expr, e->v.Dict.keys);
             +  -  +  + ]
    1618   [ -  +  +  -  :       3297 :         VISIT_SEQ(st, expr, e->v.Dict.values);
                   +  + ]
    1619                 :        397 :         break;
    1620                 :         40 :     case Set_kind:
    1621   [ -  +  +  -  :        163 :         VISIT_SEQ(st, expr, e->v.Set.elts);
                   +  + ]
    1622                 :         40 :         break;
    1623                 :        197 :     case GeneratorExp_kind:
    1624         [ -  + ]:        197 :         if (!symtable_visit_genexp(st, e))
    1625                 :          0 :             VISIT_QUIT(st, 0);
    1626                 :        197 :         break;
    1627                 :        215 :     case ListComp_kind:
    1628         [ -  + ]:        215 :         if (!symtable_visit_listcomp(st, e))
    1629                 :          0 :             VISIT_QUIT(st, 0);
    1630                 :        215 :         break;
    1631                 :         14 :     case SetComp_kind:
    1632         [ -  + ]:         14 :         if (!symtable_visit_setcomp(st, e))
    1633                 :          0 :             VISIT_QUIT(st, 0);
    1634                 :         14 :         break;
    1635                 :         23 :     case DictComp_kind:
    1636         [ -  + ]:         23 :         if (!symtable_visit_dictcomp(st, e))
    1637                 :          0 :             VISIT_QUIT(st, 0);
    1638                 :         23 :         break;
    1639                 :        252 :     case Yield_kind:
    1640         [ -  + ]:        252 :         if (!symtable_raise_if_annotation_block(st, "yield expression", e)) {
    1641                 :          0 :             VISIT_QUIT(st, 0);
    1642                 :            :         }
    1643         [ +  + ]:        252 :         if (e->v.Yield.value)
    1644         [ -  + ]:        220 :             VISIT(st, expr, e->v.Yield.value);
    1645                 :        252 :         st->st_cur->ste_generator = 1;
    1646         [ -  + ]:        252 :         if (st->st_cur->ste_comprehension) {
    1647                 :          0 :             return symtable_raise_if_comprehension_block(st, e);
    1648                 :            :         }
    1649                 :        252 :         break;
    1650                 :         44 :     case YieldFrom_kind:
    1651         [ -  + ]:         44 :         if (!symtable_raise_if_annotation_block(st, "yield expression", e)) {
    1652                 :          0 :             VISIT_QUIT(st, 0);
    1653                 :            :         }
    1654         [ -  + ]:         44 :         VISIT(st, expr, e->v.YieldFrom.value);
    1655                 :         44 :         st->st_cur->ste_generator = 1;
    1656         [ -  + ]:         44 :         if (st->st_cur->ste_comprehension) {
    1657                 :          0 :             return symtable_raise_if_comprehension_block(st, e);
    1658                 :            :         }
    1659                 :         44 :         break;
    1660                 :        128 :     case Await_kind:
    1661         [ -  + ]:        128 :         if (!symtable_raise_if_annotation_block(st, "await expression", e)) {
    1662                 :          0 :             VISIT_QUIT(st, 0);
    1663                 :            :         }
    1664         [ -  + ]:        128 :         VISIT(st, expr, e->v.Await.value);
    1665                 :        128 :         st->st_cur->ste_coroutine = 1;
    1666                 :        128 :         break;
    1667                 :       6203 :     case Compare_kind:
    1668         [ -  + ]:       6203 :         VISIT(st, expr, e->v.Compare.left);
    1669   [ -  +  +  -  :      12456 :         VISIT_SEQ(st, expr, e->v.Compare.comparators);
                   +  + ]
    1670                 :       6203 :         break;
    1671                 :      26248 :     case Call_kind:
    1672         [ -  + ]:      26248 :         VISIT(st, expr, e->v.Call.func);
    1673   [ -  +  +  +  :      59450 :         VISIT_SEQ(st, expr, e->v.Call.args);
                   +  + ]
    1674   [ -  +  -  +  :      28377 :         VISIT_SEQ_WITH_NULL(st, keyword, e->v.Call.keywords);
             +  +  +  + ]
    1675                 :      26248 :         break;
    1676                 :       1822 :     case FormattedValue_kind:
    1677         [ -  + ]:       1822 :         VISIT(st, expr, e->v.FormattedValue.value);
    1678         [ +  + ]:       1822 :         if (e->v.FormattedValue.format_spec)
    1679         [ -  + ]:         38 :             VISIT(st, expr, e->v.FormattedValue.format_spec);
    1680                 :       1822 :         break;
    1681                 :       1186 :     case JoinedStr_kind:
    1682   [ -  +  +  -  :       5009 :         VISIT_SEQ(st, expr, e->v.JoinedStr.values);
                   +  + ]
    1683                 :       1186 :         break;
    1684                 :      36974 :     case Constant_kind:
    1685                 :            :         /* Nothing to do here. */
    1686                 :      36974 :         break;
    1687                 :            :     /* The following exprs can be assignment targets. */
    1688                 :      29606 :     case Attribute_kind:
    1689         [ -  + ]:      29606 :         VISIT(st, expr, e->v.Attribute.value);
    1690                 :      29606 :         break;
    1691                 :       3484 :     case Subscript_kind:
    1692         [ -  + ]:       3484 :         VISIT(st, expr, e->v.Subscript.value);
    1693         [ -  + ]:       3484 :         VISIT(st, expr, e->v.Subscript.slice);
    1694                 :       3484 :         break;
    1695                 :        310 :     case Starred_kind:
    1696         [ -  + ]:        310 :         VISIT(st, expr, e->v.Starred.value);
    1697                 :        310 :         break;
    1698                 :        807 :     case Slice_kind:
    1699         [ +  + ]:        807 :         if (e->v.Slice.lower)
    1700         [ -  + ]:        448 :             VISIT(st, expr, e->v.Slice.lower)
    1701         [ +  + ]:        807 :         if (e->v.Slice.upper)
    1702         [ -  + ]:        479 :             VISIT(st, expr, e->v.Slice.upper)
    1703         [ +  + ]:        807 :         if (e->v.Slice.step)
    1704         [ -  + ]:          9 :             VISIT(st, expr, e->v.Slice.step)
    1705                 :        807 :         break;
    1706                 :     100938 :     case Name_kind:
    1707         [ -  + ]:     100938 :         if (!symtable_add_def(st, e->v.Name.id,
    1708         [ +  + ]:     100938 :                               e->v.Name.ctx == Load ? USE : DEF_LOCAL, LOCATION(e)))
    1709                 :          0 :             VISIT_QUIT(st, 0);
    1710                 :            :         /* Special-case super: it counts as a use of __class__ */
    1711         [ +  + ]:     100938 :         if (e->v.Name.ctx == Load &&
    1712   [ +  +  +  + ]:     161065 :             st->st_cur->ste_type == FunctionBlock &&
    1713                 :      77401 :             _PyUnicode_EqualToASCIIString(e->v.Name.id, "super")) {
    1714         [ -  + ]:        219 :             if (!symtable_add_def(st, &_Py_ID(__class__), USE, LOCATION(e)))
    1715                 :          0 :                 VISIT_QUIT(st, 0);
    1716                 :            :         }
    1717                 :     100938 :         break;
    1718                 :            :     /* child nodes of List and Tuple will have expr_context set */
    1719                 :       1029 :     case List_kind:
    1720   [ -  +  +  +  :       3920 :         VISIT_SEQ(st, expr, e->v.List.elts);
                   +  + ]
    1721                 :       1029 :         break;
    1722                 :       2953 :     case Tuple_kind:
    1723   [ -  +  +  -  :      10174 :         VISIT_SEQ(st, expr, e->v.Tuple.elts);
                   +  + ]
    1724                 :       2953 :         break;
    1725                 :            :     }
    1726                 :     220307 :     VISIT_QUIT(st, 1);
    1727                 :            : }
    1728                 :            : 
    1729                 :            : static int
    1730                 :         19 : symtable_visit_pattern(struct symtable *st, pattern_ty p)
    1731                 :            : {
    1732         [ -  + ]:         19 :     if (++st->recursion_depth > st->recursion_limit) {
    1733                 :          0 :         PyErr_SetString(PyExc_RecursionError,
    1734                 :            :                         "maximum recursion depth exceeded during compilation");
    1735                 :          0 :         VISIT_QUIT(st, 0);
    1736                 :            :     }
    1737   [ +  +  +  +  :         19 :     switch (p->kind) {
             -  +  +  -  
                      - ]
    1738                 :          4 :     case MatchValue_kind:
    1739         [ -  + ]:          4 :         VISIT(st, expr, p->v.MatchValue.value);
    1740                 :          4 :         break;
    1741                 :          1 :     case MatchSingleton_kind:
    1742                 :            :         /* Nothing to do here. */
    1743                 :          1 :         break;
    1744                 :          5 :     case MatchSequence_kind:
    1745   [ -  +  +  -  :         10 :         VISIT_SEQ(st, pattern, p->v.MatchSequence.patterns);
                   +  + ]
    1746                 :          5 :         break;
    1747                 :          1 :     case MatchStar_kind:
    1748         [ +  - ]:          1 :         if (p->v.MatchStar.name) {
    1749                 :          1 :             symtable_add_def(st, p->v.MatchStar.name, DEF_LOCAL, LOCATION(p));
    1750                 :            :         }
    1751                 :          1 :         break;
    1752                 :          0 :     case MatchMapping_kind:
    1753   [ #  #  #  #  :          0 :         VISIT_SEQ(st, expr, p->v.MatchMapping.keys);
                   #  # ]
    1754   [ #  #  #  #  :          0 :         VISIT_SEQ(st, pattern, p->v.MatchMapping.patterns);
                   #  # ]
    1755         [ #  # ]:          0 :         if (p->v.MatchMapping.rest) {
    1756                 :          0 :             symtable_add_def(st, p->v.MatchMapping.rest, DEF_LOCAL, LOCATION(p));
    1757                 :            :         }
    1758                 :          0 :         break;
    1759                 :          4 :     case MatchClass_kind:
    1760         [ -  + ]:          4 :         VISIT(st, expr, p->v.MatchClass.cls);
    1761   [ -  +  +  +  :          6 :         VISIT_SEQ(st, pattern, p->v.MatchClass.patterns);
                   +  + ]
    1762   [ -  -  -  +  :          4 :         VISIT_SEQ(st, pattern, p->v.MatchClass.kwd_patterns);
                   -  + ]
    1763                 :          4 :         break;
    1764                 :          4 :     case MatchAs_kind:
    1765         [ -  + ]:          4 :         if (p->v.MatchAs.pattern) {
    1766         [ #  # ]:          0 :             VISIT(st, pattern, p->v.MatchAs.pattern);
    1767                 :            :         }
    1768         [ +  + ]:          4 :         if (p->v.MatchAs.name) {
    1769                 :          3 :             symtable_add_def(st, p->v.MatchAs.name, DEF_LOCAL, LOCATION(p));
    1770                 :            :         }
    1771                 :          4 :         break;
    1772                 :          0 :     case MatchOr_kind:
    1773   [ #  #  #  #  :          0 :         VISIT_SEQ(st, pattern, p->v.MatchOr.patterns);
                   #  # ]
    1774                 :          0 :         break;
    1775                 :            :     }
    1776                 :         19 :     VISIT_QUIT(st, 1);
    1777                 :            : }
    1778                 :            : 
    1779                 :            : static int
    1780                 :        449 : symtable_implicit_arg(struct symtable *st, int pos)
    1781                 :            : {
    1782                 :        449 :     PyObject *id = PyUnicode_FromFormat(".%d", pos);
    1783         [ -  + ]:        449 :     if (id == NULL)
    1784                 :          0 :         return 0;
    1785         [ -  + ]:        449 :     if (!symtable_add_def(st, id, DEF_PARAM, ST_LOCATION(st->st_cur))) {
    1786                 :          0 :         Py_DECREF(id);
    1787                 :          0 :         return 0;
    1788                 :            :     }
    1789                 :        449 :     Py_DECREF(id);
    1790                 :        449 :     return 1;
    1791                 :            : }
    1792                 :            : 
    1793                 :            : static int
    1794                 :      19608 : symtable_visit_params(struct symtable *st, asdl_arg_seq *args)
    1795                 :            : {
    1796                 :            :     int i;
    1797                 :            : 
    1798         [ -  + ]:      19608 :     if (!args)
    1799                 :          0 :         return -1;
    1800                 :            : 
    1801   [ +  -  +  + ]:      32603 :     for (i = 0; i < asdl_seq_LEN(args); i++) {
    1802                 :      12995 :         arg_ty arg = (arg_ty)asdl_seq_GET(args, i);
    1803         [ -  + ]:      12995 :         if (!symtable_add_def(st, arg->arg, DEF_PARAM, LOCATION(arg)))
    1804                 :          0 :             return 0;
    1805                 :            :     }
    1806                 :            : 
    1807                 :      19608 :     return 1;
    1808                 :            : }
    1809                 :            : 
    1810                 :            : static int
    1811                 :        258 : symtable_visit_annotation(struct symtable *st, expr_ty annotation)
    1812                 :            : {
    1813                 :        258 :     int future_annotations = st->st_future->ff_features & CO_FUTURE_ANNOTATIONS;
    1814   [ -  +  -  - ]:        258 :     if (future_annotations &&
    1815                 :          0 :         !symtable_enter_block(st, &_Py_ID(_annotation), AnnotationBlock,
    1816                 :            :                               (void *)annotation, annotation->lineno,
    1817                 :            :                               annotation->col_offset, annotation->end_lineno,
    1818                 :            :                               annotation->end_col_offset)) {
    1819                 :          0 :         VISIT_QUIT(st, 0);
    1820                 :            :     }
    1821         [ -  + ]:        258 :     VISIT(st, expr, annotation);
    1822   [ -  +  -  - ]:        258 :     if (future_annotations && !symtable_exit_block(st)) {
    1823                 :          0 :         VISIT_QUIT(st, 0);
    1824                 :            :     }
    1825                 :        258 :     return 1;
    1826                 :            : }
    1827                 :            : 
    1828                 :            : static int
    1829                 :      19203 : symtable_visit_argannotations(struct symtable *st, asdl_arg_seq *args)
    1830                 :            : {
    1831                 :            :     int i;
    1832                 :            : 
    1833         [ -  + ]:      19203 :     if (!args)
    1834                 :          0 :         return -1;
    1835                 :            : 
    1836   [ +  -  +  + ]:      31849 :     for (i = 0; i < asdl_seq_LEN(args); i++) {
    1837                 :      12646 :         arg_ty arg = (arg_ty)asdl_seq_GET(args, i);
    1838         [ +  + ]:      12646 :         if (arg->annotation)
    1839         [ -  + ]:        353 :             VISIT(st, expr, arg->annotation);
    1840                 :            :     }
    1841                 :            : 
    1842                 :      19203 :     return 1;
    1843                 :            : }
    1844                 :            : 
    1845                 :            : static int
    1846                 :       6401 : symtable_visit_annotations(struct symtable *st, stmt_ty o, arguments_ty a, expr_ty returns)
    1847                 :            : {
    1848                 :       6401 :     int future_annotations = st->st_future->ff_features & CO_FUTURE_ANNOTATIONS;
    1849   [ -  +  -  - ]:       6401 :     if (future_annotations &&
    1850                 :          0 :         !symtable_enter_block(st, &_Py_ID(_annotation), AnnotationBlock,
    1851                 :            :                               (void *)o, o->lineno, o->col_offset, o->end_lineno,
    1852                 :            :                               o->end_col_offset)) {
    1853                 :          0 :         VISIT_QUIT(st, 0);
    1854                 :            :     }
    1855   [ +  -  -  + ]:       6401 :     if (a->posonlyargs && !symtable_visit_argannotations(st, a->posonlyargs))
    1856                 :          0 :         return 0;
    1857   [ +  -  -  + ]:       6401 :     if (a->args && !symtable_visit_argannotations(st, a->args))
    1858                 :          0 :         return 0;
    1859   [ +  +  +  + ]:       6401 :     if (a->vararg && a->vararg->annotation)
    1860         [ -  + ]:          1 :         VISIT(st, expr, a->vararg->annotation);
    1861   [ +  +  +  + ]:       6401 :     if (a->kwarg && a->kwarg->annotation)
    1862         [ -  + ]:          2 :         VISIT(st, expr, a->kwarg->annotation);
    1863   [ +  -  -  + ]:       6401 :     if (a->kwonlyargs && !symtable_visit_argannotations(st, a->kwonlyargs))
    1864                 :          0 :         return 0;
    1865   [ -  +  -  - ]:       6401 :     if (future_annotations && !symtable_exit_block(st)) {
    1866                 :          0 :         VISIT_QUIT(st, 0);
    1867                 :            :     }
    1868   [ +  +  -  + ]:       6401 :     if (returns && !symtable_visit_annotation(st, returns)) {
    1869                 :          0 :         VISIT_QUIT(st, 0);
    1870                 :            :     }
    1871                 :       6401 :     return 1;
    1872                 :            : }
    1873                 :            : 
    1874                 :            : static int
    1875                 :       6536 : symtable_visit_arguments(struct symtable *st, arguments_ty a)
    1876                 :            : {
    1877                 :            :     /* skip default arguments inside function block
    1878                 :            :        XXX should ast be different?
    1879                 :            :     */
    1880   [ +  -  -  + ]:       6536 :     if (a->posonlyargs && !symtable_visit_params(st, a->posonlyargs))
    1881                 :          0 :         return 0;
    1882   [ +  -  -  + ]:       6536 :     if (a->args && !symtable_visit_params(st, a->args))
    1883                 :          0 :         return 0;
    1884   [ +  -  -  + ]:       6536 :     if (a->kwonlyargs && !symtable_visit_params(st, a->kwonlyargs))
    1885                 :          0 :         return 0;
    1886         [ +  + ]:       6536 :     if (a->vararg) {
    1887         [ -  + ]:        309 :         if (!symtable_add_def(st, a->vararg->arg, DEF_PARAM, LOCATION(a->vararg)))
    1888                 :          0 :             return 0;
    1889                 :        309 :         st->st_cur->ste_varargs = 1;
    1890                 :            :     }
    1891         [ +  + ]:       6536 :     if (a->kwarg) {
    1892         [ -  + ]:        216 :         if (!symtable_add_def(st, a->kwarg->arg, DEF_PARAM, LOCATION(a->kwarg)))
    1893                 :          0 :             return 0;
    1894                 :        216 :         st->st_cur->ste_varkeywords = 1;
    1895                 :            :     }
    1896                 :       6536 :     return 1;
    1897                 :            : }
    1898                 :            : 
    1899                 :            : 
    1900                 :            : static int
    1901                 :       1431 : symtable_visit_excepthandler(struct symtable *st, excepthandler_ty eh)
    1902                 :            : {
    1903         [ +  + ]:       1431 :     if (eh->v.ExceptHandler.type)
    1904         [ -  + ]:       1364 :         VISIT(st, expr, eh->v.ExceptHandler.type);
    1905         [ +  + ]:       1431 :     if (eh->v.ExceptHandler.name)
    1906         [ -  + ]:        261 :         if (!symtable_add_def(st, eh->v.ExceptHandler.name, DEF_LOCAL, LOCATION(eh)))
    1907                 :          0 :             return 0;
    1908   [ -  +  +  -  :       3347 :     VISIT_SEQ(st, stmt, eh->v.ExceptHandler.body);
                   +  + ]
    1909                 :       1431 :     return 1;
    1910                 :            : }
    1911                 :            : 
    1912                 :            : static int
    1913                 :        388 : symtable_visit_withitem(struct symtable *st, withitem_ty item)
    1914                 :            : {
    1915         [ -  + ]:        388 :     VISIT(st, expr, item->context_expr);
    1916         [ +  + ]:        388 :     if (item->optional_vars) {
    1917         [ -  + ]:        143 :         VISIT(st, expr, item->optional_vars);
    1918                 :            :     }
    1919                 :        388 :     return 1;
    1920                 :            : }
    1921                 :            : 
    1922                 :            : static int
    1923                 :         12 : symtable_visit_match_case(struct symtable *st, match_case_ty m)
    1924                 :            : {
    1925         [ -  + ]:         12 :     VISIT(st, pattern, m->pattern);
    1926         [ +  + ]:         12 :     if (m->guard) {
    1927         [ -  + ]:          1 :         VISIT(st, expr, m->guard);
    1928                 :            :     }
    1929   [ -  +  +  -  :         33 :     VISIT_SEQ(st, stmt, m->body);
                   +  + ]
    1930                 :         12 :     return 1;
    1931                 :            : }
    1932                 :            : 
    1933                 :            : static int
    1934                 :       1740 : symtable_visit_alias(struct symtable *st, alias_ty a)
    1935                 :            : {
    1936                 :            :     /* Compute store_name, the name actually bound by the import
    1937                 :            :        operation.  It is different than a->name when a->name is a
    1938                 :            :        dotted package name (e.g. spam.eggs)
    1939                 :            :     */
    1940                 :            :     PyObject *store_name;
    1941         [ +  + ]:       1740 :     PyObject *name = (a->asname == NULL) ? a->name : a->asname;
    1942                 :       1740 :     Py_ssize_t dot = PyUnicode_FindChar(name, '.', 0,
    1943                 :            :                                         PyUnicode_GET_LENGTH(name), 1);
    1944         [ +  + ]:       1740 :     if (dot != -1) {
    1945                 :         22 :         store_name = PyUnicode_Substring(name, 0, dot);
    1946         [ -  + ]:         22 :         if (!store_name)
    1947                 :          0 :             return 0;
    1948                 :            :     }
    1949                 :            :     else {
    1950                 :       1718 :         store_name = Py_NewRef(name);
    1951                 :            :     }
    1952         [ +  + ]:       1740 :     if (!_PyUnicode_EqualToASCIIString(name, "*")) {
    1953                 :       1692 :         int r = symtable_add_def(st, store_name, DEF_IMPORT, LOCATION(a));
    1954                 :       1692 :         Py_DECREF(store_name);
    1955                 :       1692 :         return r;
    1956                 :            :     }
    1957                 :            :     else {
    1958         [ -  + ]:         48 :         if (st->st_cur->ste_type != ModuleBlock) {
    1959                 :          0 :             int lineno = a->lineno;
    1960                 :          0 :             int col_offset = a->col_offset;
    1961                 :          0 :             int end_lineno = a->end_lineno;
    1962                 :          0 :             int end_col_offset = a->end_col_offset;
    1963                 :          0 :             PyErr_SetString(PyExc_SyntaxError, IMPORT_STAR_WARNING);
    1964                 :          0 :             PyErr_RangedSyntaxLocationObject(st->st_filename,
    1965                 :            :                                              lineno, col_offset + 1,
    1966                 :            :                                              end_lineno, end_col_offset + 1);
    1967                 :          0 :             Py_DECREF(store_name);
    1968                 :          0 :             return 0;
    1969                 :            :         }
    1970                 :         48 :         Py_DECREF(store_name);
    1971                 :         48 :         return 1;
    1972                 :            :     }
    1973                 :            : }
    1974                 :            : 
    1975                 :            : 
    1976                 :            : static int
    1977                 :         18 : symtable_visit_comprehension(struct symtable *st, comprehension_ty lc)
    1978                 :            : {
    1979                 :         18 :     st->st_cur->ste_comp_iter_target = 1;
    1980         [ -  + ]:         18 :     VISIT(st, expr, lc->target);
    1981                 :         18 :     st->st_cur->ste_comp_iter_target = 0;
    1982                 :         18 :     st->st_cur->ste_comp_iter_expr++;
    1983         [ -  + ]:         18 :     VISIT(st, expr, lc->iter);
    1984                 :         18 :     st->st_cur->ste_comp_iter_expr--;
    1985   [ -  +  +  -  :         19 :     VISIT_SEQ(st, expr, lc->ifs);
                   +  + ]
    1986         [ -  + ]:         18 :     if (lc->is_async) {
    1987                 :          0 :         st->st_cur->ste_coroutine = 1;
    1988                 :            :     }
    1989                 :         18 :     return 1;
    1990                 :            : }
    1991                 :            : 
    1992                 :            : 
    1993                 :            : static int
    1994                 :       2185 : symtable_visit_keyword(struct symtable *st, keyword_ty k)
    1995                 :            : {
    1996         [ -  + ]:       2185 :     VISIT(st, expr, k->value);
    1997                 :       2185 :     return 1;
    1998                 :            : }
    1999                 :            : 
    2000                 :            : 
    2001                 :            : static int
    2002                 :        449 : symtable_handle_comprehension(struct symtable *st, expr_ty e,
    2003                 :            :                               identifier scope_name, asdl_comprehension_seq *generators,
    2004                 :            :                               expr_ty elt, expr_ty value)
    2005                 :            : {
    2006                 :        449 :     int is_generator = (e->kind == GeneratorExp_kind);
    2007                 :        449 :     comprehension_ty outermost = ((comprehension_ty)
    2008                 :            :                                     asdl_seq_GET(generators, 0));
    2009                 :            :     /* Outermost iterator is evaluated in current scope */
    2010                 :        449 :     st->st_cur->ste_comp_iter_expr++;
    2011         [ -  + ]:        449 :     VISIT(st, expr, outermost->iter);
    2012                 :        449 :     st->st_cur->ste_comp_iter_expr--;
    2013                 :            :     /* Create comprehension scope for the rest */
    2014   [ +  -  -  + ]:        898 :     if (!scope_name ||
    2015                 :        449 :         !symtable_enter_block(st, scope_name, FunctionBlock, (void *)e,
    2016                 :            :                               e->lineno, e->col_offset,
    2017                 :            :                               e->end_lineno, e->end_col_offset)) {
    2018                 :          0 :         return 0;
    2019                 :            :     }
    2020   [ +  +  +  + ]:        449 :     switch(e->kind) {
    2021                 :        215 :         case ListComp_kind:
    2022                 :        215 :             st->st_cur->ste_comprehension = ListComprehension;
    2023                 :        215 :             break;
    2024                 :         14 :         case SetComp_kind:
    2025                 :         14 :             st->st_cur->ste_comprehension = SetComprehension;
    2026                 :         14 :             break;
    2027                 :         23 :         case DictComp_kind:
    2028                 :         23 :             st->st_cur->ste_comprehension = DictComprehension;
    2029                 :         23 :             break;
    2030                 :        197 :         default:
    2031                 :        197 :             st->st_cur->ste_comprehension = GeneratorExpression;
    2032                 :        197 :             break;
    2033                 :            :     }
    2034         [ -  + ]:        449 :     if (outermost->is_async) {
    2035                 :          0 :         st->st_cur->ste_coroutine = 1;
    2036                 :            :     }
    2037                 :            : 
    2038                 :            :     /* Outermost iter is received as an argument */
    2039         [ -  + ]:        449 :     if (!symtable_implicit_arg(st, 0)) {
    2040                 :          0 :         symtable_exit_block(st);
    2041                 :          0 :         return 0;
    2042                 :            :     }
    2043                 :            :     /* Visit iteration variable target, and mark them as such */
    2044                 :        449 :     st->st_cur->ste_comp_iter_target = 1;
    2045         [ -  + ]:        449 :     VISIT(st, expr, outermost->target);
    2046                 :        449 :     st->st_cur->ste_comp_iter_target = 0;
    2047                 :            :     /* Visit the rest of the comprehension body */
    2048   [ -  +  +  -  :        564 :     VISIT_SEQ(st, expr, outermost->ifs);
                   +  + ]
    2049   [ -  +  +  -  :        467 :     VISIT_SEQ_TAIL(st, comprehension, generators, 1);
                   +  + ]
    2050         [ +  + ]:        449 :     if (value)
    2051         [ -  + ]:         23 :         VISIT(st, expr, value);
    2052         [ -  + ]:        449 :     VISIT(st, expr, elt);
    2053                 :        449 :     st->st_cur->ste_generator = is_generator;
    2054   [ -  +  -  - ]:        449 :     int is_async = st->st_cur->ste_coroutine && !is_generator;
    2055         [ -  + ]:        449 :     if (!symtable_exit_block(st)) {
    2056                 :          0 :         return 0;
    2057                 :            :     }
    2058         [ -  + ]:        449 :     if (is_async) {
    2059                 :          0 :         st->st_cur->ste_coroutine = 1;
    2060                 :            :     }
    2061                 :        449 :     return 1;
    2062                 :            : }
    2063                 :            : 
    2064                 :            : static int
    2065                 :        197 : symtable_visit_genexp(struct symtable *st, expr_ty e)
    2066                 :            : {
    2067                 :        197 :     return symtable_handle_comprehension(st, e, &_Py_ID(genexpr),
    2068                 :            :                                          e->v.GeneratorExp.generators,
    2069                 :            :                                          e->v.GeneratorExp.elt, NULL);
    2070                 :            : }
    2071                 :            : 
    2072                 :            : static int
    2073                 :        215 : symtable_visit_listcomp(struct symtable *st, expr_ty e)
    2074                 :            : {
    2075                 :        215 :     return symtable_handle_comprehension(st, e, &_Py_ID(listcomp),
    2076                 :            :                                          e->v.ListComp.generators,
    2077                 :            :                                          e->v.ListComp.elt, NULL);
    2078                 :            : }
    2079                 :            : 
    2080                 :            : static int
    2081                 :         14 : symtable_visit_setcomp(struct symtable *st, expr_ty e)
    2082                 :            : {
    2083                 :         14 :     return symtable_handle_comprehension(st, e, &_Py_ID(setcomp),
    2084                 :            :                                          e->v.SetComp.generators,
    2085                 :            :                                          e->v.SetComp.elt, NULL);
    2086                 :            : }
    2087                 :            : 
    2088                 :            : static int
    2089                 :         23 : symtable_visit_dictcomp(struct symtable *st, expr_ty e)
    2090                 :            : {
    2091                 :         23 :     return symtable_handle_comprehension(st, e, &_Py_ID(dictcomp),
    2092                 :            :                                          e->v.DictComp.generators,
    2093                 :            :                                          e->v.DictComp.key,
    2094                 :            :                                          e->v.DictComp.value);
    2095                 :            : }
    2096                 :            : 
    2097                 :            : static int
    2098                 :        447 : symtable_raise_if_annotation_block(struct symtable *st, const char *name, expr_ty e)
    2099                 :            : {
    2100         [ +  - ]:        447 :     if (st->st_cur->ste_type != AnnotationBlock) {
    2101                 :        447 :         return 1;
    2102                 :            :     }
    2103                 :            : 
    2104                 :          0 :     PyErr_Format(PyExc_SyntaxError, ANNOTATION_NOT_ALLOWED, name);
    2105                 :          0 :     PyErr_RangedSyntaxLocationObject(st->st_filename,
    2106                 :            :                                      e->lineno,
    2107                 :          0 :                                      e->col_offset + 1,
    2108                 :            :                                      e->end_lineno,
    2109                 :          0 :                                      e->end_col_offset + 1);
    2110                 :          0 :     return 0;
    2111                 :            : }
    2112                 :            : 
    2113                 :            : static int
    2114                 :          0 : symtable_raise_if_comprehension_block(struct symtable *st, expr_ty e) {
    2115                 :          0 :     _Py_comprehension_ty type = st->st_cur->ste_comprehension;
    2116         [ #  # ]:          0 :     PyErr_SetString(PyExc_SyntaxError,
    2117   [ #  #  #  # ]:          0 :             (type == ListComprehension) ? "'yield' inside list comprehension" :
    2118                 :            :             (type == SetComprehension) ? "'yield' inside set comprehension" :
    2119                 :            :             (type == DictComprehension) ? "'yield' inside dict comprehension" :
    2120                 :            :             "'yield' inside generator expression");
    2121                 :          0 :     PyErr_RangedSyntaxLocationObject(st->st_filename,
    2122                 :          0 :                                      e->lineno, e->col_offset + 1,
    2123                 :          0 :                                      e->end_lineno, e->end_col_offset + 1);
    2124                 :          0 :     VISIT_QUIT(st, 0);
    2125                 :            : }
    2126                 :            : 
    2127                 :            : struct symtable *
    2128                 :          0 : _Py_SymtableStringObjectFlags(const char *str, PyObject *filename,
    2129                 :            :                               int start, PyCompilerFlags *flags)
    2130                 :            : {
    2131                 :            :     struct symtable *st;
    2132                 :            :     mod_ty mod;
    2133                 :            :     PyArena *arena;
    2134                 :            : 
    2135                 :          0 :     arena = _PyArena_New();
    2136         [ #  # ]:          0 :     if (arena == NULL)
    2137                 :          0 :         return NULL;
    2138                 :            : 
    2139                 :          0 :     mod = _PyParser_ASTFromString(str, filename, start, flags, arena);
    2140         [ #  # ]:          0 :     if (mod == NULL) {
    2141                 :          0 :         _PyArena_Free(arena);
    2142                 :          0 :         return NULL;
    2143                 :            :     }
    2144                 :            :     PyFutureFeatures future;
    2145         [ #  # ]:          0 :     if (!_PyFuture_FromAST(mod, filename, &future)) {
    2146                 :          0 :         _PyArena_Free(arena);
    2147                 :          0 :         return NULL;
    2148                 :            :     }
    2149                 :          0 :     future.ff_features |= flags->cf_flags;
    2150                 :          0 :     st = _PySymtable_Build(mod, filename, &future);
    2151                 :          0 :     _PyArena_Free(arena);
    2152                 :          0 :     return st;
    2153                 :            : }
    2154                 :            : 
    2155                 :            : PyObject *
    2156                 :     278773 : _Py_Mangle(PyObject *privateobj, PyObject *ident)
    2157                 :            : {
    2158                 :            :     /* Name mangling: __private becomes _classname__private.
    2159                 :            :        This is independent from how the name is used. */
    2160   [ +  +  +  -  :     435495 :     if (privateobj == NULL || !PyUnicode_Check(privateobj) ||
                   +  + ]
    2161         [ +  + ]:     177710 :         PyUnicode_READ_CHAR(ident, 0) != '_' ||
    2162                 :      20988 :         PyUnicode_READ_CHAR(ident, 1) != '_') {
    2163                 :     269426 :         return Py_NewRef(ident);
    2164                 :            :     }
    2165                 :       9347 :     size_t nlen = PyUnicode_GET_LENGTH(ident);
    2166                 :       9347 :     size_t plen = PyUnicode_GET_LENGTH(privateobj);
    2167                 :            :     /* Don't mangle __id__ or names with dots.
    2168                 :            : 
    2169                 :            :        The only time a name with a dot can occur is when
    2170                 :            :        we are compiling an import statement that has a
    2171                 :            :        package name.
    2172                 :            : 
    2173                 :            :        TODO(jhylton): Decide whether we want to support
    2174                 :            :        mangling of the module name, e.g. __M.X.
    2175                 :            :     */
    2176   [ +  +  -  + ]:      18487 :     if ((PyUnicode_READ_CHAR(ident, nlen-1) == '_' &&
    2177         [ -  + ]:       9347 :          PyUnicode_READ_CHAR(ident, nlen-2) == '_') ||
    2178                 :        207 :         PyUnicode_FindChar(ident, '.', 0, nlen, 1) != -1) {
    2179                 :       9140 :         return Py_NewRef(ident); /* Don't mangle __whatever__ */
    2180                 :            :     }
    2181                 :            :     /* Strip leading underscores from class name */
    2182                 :        207 :     size_t ipriv = 0;
    2183         [ +  + ]:        262 :     while (PyUnicode_READ_CHAR(privateobj, ipriv) == '_') {
    2184                 :         55 :         ipriv++;
    2185                 :            :     }
    2186         [ -  + ]:        207 :     if (ipriv == plen) {
    2187                 :          0 :         return Py_NewRef(ident); /* Don't mangle if class is just underscores */
    2188                 :            :     }
    2189                 :        207 :     plen -= ipriv;
    2190                 :            : 
    2191         [ -  + ]:        207 :     if (plen + nlen >= PY_SSIZE_T_MAX - 1) {
    2192                 :          0 :         PyErr_SetString(PyExc_OverflowError,
    2193                 :            :                         "private identifier too large to be mangled");
    2194                 :          0 :         return NULL;
    2195                 :            :     }
    2196                 :            : 
    2197                 :        207 :     Py_UCS4 maxchar = PyUnicode_MAX_CHAR_VALUE(ident);
    2198         [ -  + ]:        207 :     if (PyUnicode_MAX_CHAR_VALUE(privateobj) > maxchar) {
    2199                 :          0 :         maxchar = PyUnicode_MAX_CHAR_VALUE(privateobj);
    2200                 :            :     }
    2201                 :            : 
    2202                 :        207 :     PyObject *result = PyUnicode_New(1 + nlen + plen, maxchar);
    2203         [ -  + ]:        207 :     if (!result) {
    2204                 :          0 :         return NULL;
    2205                 :            :     }
    2206                 :            :     /* ident = "_" + priv[ipriv:] + ident # i.e. 1+plen+nlen bytes */
    2207                 :        207 :     PyUnicode_WRITE(PyUnicode_KIND(result), PyUnicode_DATA(result), 0, '_');
    2208         [ -  + ]:        207 :     if (PyUnicode_CopyCharacters(result, 1, privateobj, ipriv, plen) < 0) {
    2209                 :          0 :         Py_DECREF(result);
    2210                 :          0 :         return NULL;
    2211                 :            :     }
    2212         [ -  + ]:        207 :     if (PyUnicode_CopyCharacters(result, plen+1, ident, 0, nlen) < 0) {
    2213                 :          0 :         Py_DECREF(result);
    2214                 :          0 :         return NULL;
    2215                 :            :     }
    2216                 :            :     assert(_PyUnicode_CheckConsistency(result, 1));
    2217                 :        207 :     return result;
    2218                 :            : }
    2219                 :            : 

Generated by: LCOV version 1.14