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