Python code coverage for Lib/compiler/ast.py

#	count	content
1	n/a	"""Python abstract syntax node definitions
2	n/a
3	n/a	This file is automatically generated by Tools/compiler/astgen.py
4	2	"""
5	2	from compiler.consts import CO_VARARGS, CO_VARKEYWORDS
6	n/a
7	2	def flatten(seq):
8	40940	l = []
9	112138	for elt in seq:
10	71198	t = type(elt)
11	71198	if t is tuple or t is list:
12	9066	for elt2 in flatten(elt):
13	6268	l.append(elt2)
14	n/a	else:
15	68400	l.append(elt)
16	40940	return l
17	n/a
18	2	def flatten_nodes(seq):
19	106536	return [n for n in flatten(seq) if isinstance(n, Node)]
20	n/a
21	2	nodes = {}
22	n/a
23	4	class Node:
24	2	"""Abstract base class for ast nodes."""
25	2	def getChildren(self):
26	0	pass # implemented by subclasses
27	2	def __iter__(self):
28	0	for n in self.getChildren():
29	0	yield n
30	2	def asList(self): # for backwards compatibility
31	0	return self.getChildren()
32	2	def getChildNodes(self):
33	0	pass # implemented by subclasses
34	n/a
35	4	class EmptyNode(Node):
36	2	pass
37	n/a
38	4	class Expression(Node):
39	n/a	# Expression is an artificial node class to support "eval"
40	2	nodes["expression"] = "Expression"
41	2	def __init__(self, node):
42	9	self.node = node
43	n/a
44	2	def getChildren(self):
45	0	return self.node,
46	n/a
47	2	def getChildNodes(self):
48	18	return self.node,
49	n/a
50	2	def __repr__(self):
51	0	return "Expression(%s)" % (repr(self.node))
52	n/a
53	4	class Add(Node):
54	2	def __init__(self, leftright, lineno=None):
55	97	self.left = leftright[0]
56	97	self.right = leftright[1]
57	97	self.lineno = lineno
58	n/a
59	2	def getChildren(self):
60	0	return self.left, self.right
61	n/a
62	2	def getChildNodes(self):
63	447	return self.left, self.right
64	n/a
65	2	def __repr__(self):
66	0	return "Add((%s, %s))" % (repr(self.left), repr(self.right))
67	n/a
68	4	class And(Node):
69	2	def __init__(self, nodes, lineno=None):
70	10	self.nodes = nodes
71	10	self.lineno = lineno
72	n/a
73	2	def getChildren(self):
74	0	return tuple(flatten(self.nodes))
75	n/a
76	2	def getChildNodes(self):
77	46	nodelist = []
78	46	nodelist.extend(flatten_nodes(self.nodes))
79	46	return tuple(nodelist)
80	n/a
81	2	def __repr__(self):
82	0	return "And(%s)" % (repr(self.nodes),)
83	n/a
84	4	class AssAttr(Node):
85	2	def __init__(self, expr, attrname, flags, lineno=None):
86	339	self.expr = expr
87	339	self.attrname = attrname
88	339	self.flags = flags
89	339	self.lineno = lineno
90	n/a
91	2	def getChildren(self):
92	0	return self.expr, self.attrname, self.flags
93	n/a
94	2	def getChildNodes(self):
95	1044	return self.expr,
96	n/a
97	2	def __repr__(self):
98	0	return "AssAttr(%s, %s, %s)" % (repr(self.expr), repr(self.attrname), repr(self.flags))
99	n/a
100	4	class AssList(Node):
101	2	def __init__(self, nodes, lineno=None):
102	1	self.nodes = nodes
103	1	self.lineno = lineno
104	n/a
105	2	def getChildren(self):
106	0	return tuple(flatten(self.nodes))
107	n/a
108	2	def getChildNodes(self):
109	1	nodelist = []
110	1	nodelist.extend(flatten_nodes(self.nodes))
111	1	return tuple(nodelist)
112	n/a
113	2	def __repr__(self):
114	0	return "AssList(%s)" % (repr(self.nodes),)
115	n/a
116	4	class AssName(Node):
117	2	def __init__(self, name, flags, lineno=None):
118	911	self.name = name
119	911	self.flags = flags
120	911	self.lineno = lineno
121	n/a
122	2	def getChildren(self):
123	0	return self.name, self.flags
124	n/a
125	2	def getChildNodes(self):
126	1887	return ()
127	n/a
128	2	def __repr__(self):
129	0	return "AssName(%s, %s)" % (repr(self.name), repr(self.flags))
130	n/a
131	4	class AssTuple(Node):
132	2	def __init__(self, nodes, lineno=None):
133	43	self.nodes = nodes
134	43	self.lineno = lineno
135	n/a
136	2	def getChildren(self):
137	0	return tuple(flatten(self.nodes))
138	n/a
139	2	def getChildNodes(self):
140	196	nodelist = []
141	196	nodelist.extend(flatten_nodes(self.nodes))
142	196	return tuple(nodelist)
143	n/a
144	2	def __repr__(self):
145	0	return "AssTuple(%s)" % (repr(self.nodes),)
146	n/a
147	4	class Assert(Node):
148	2	def __init__(self, test, fail, lineno=None):
149	3	self.test = test
150	3	self.fail = fail
151	3	self.lineno = lineno
152	n/a
153	2	def getChildren(self):
154	0	children = []
155	0	children.append(self.test)
156	0	children.append(self.fail)
157	0	return tuple(children)
158	n/a
159	2	def getChildNodes(self):
160	15	nodelist = []
161	15	nodelist.append(self.test)
162	15	if self.fail is not None:
163	5	nodelist.append(self.fail)
164	15	return tuple(nodelist)
165	n/a
166	2	def __repr__(self):
167	0	return "Assert(%s, %s)" % (repr(self.test), repr(self.fail))
168	n/a
169	4	class Assign(Node):
170	2	def __init__(self, nodes, expr, lineno=None):
171	1038	self.nodes = nodes
172	1038	self.expr = expr
173	1038	self.lineno = lineno
174	n/a
175	2	def getChildren(self):
176	0	children = []
177	0	children.extend(flatten(self.nodes))
178	0	children.append(self.expr)
179	0	return tuple(children)
180	n/a
181	2	def getChildNodes(self):
182	2974	nodelist = []
183	2974	nodelist.extend(flatten_nodes(self.nodes))
184	2974	nodelist.append(self.expr)
185	2974	return tuple(nodelist)
186	n/a
187	2	def __repr__(self):
188	0	return "Assign(%s, %s)" % (repr(self.nodes), repr(self.expr))
189	n/a
190	4	class AugAssign(Node):
191	2	def __init__(self, node, op, expr, lineno=None):
192	19	self.node = node
193	19	self.op = op
194	19	self.expr = expr
195	19	self.lineno = lineno
196	n/a
197	2	def getChildren(self):
198	0	return self.node, self.op, self.expr
199	n/a
200	2	def getChildNodes(self):
201	70	return self.node, self.expr
202	n/a
203	2	def __repr__(self):
204	0	return "AugAssign(%s, %s, %s)" % (repr(self.node), repr(self.op), repr(self.expr))
205	n/a
206	4	class Backquote(Node):
207	2	def __init__(self, expr, lineno=None):
208	0	self.expr = expr
209	0	self.lineno = lineno
210	n/a
211	2	def getChildren(self):
212	0	return self.expr,
213	n/a
214	2	def getChildNodes(self):
215	0	return self.expr,
216	n/a
217	2	def __repr__(self):
218	0	return "Backquote(%s)" % (repr(self.expr),)
219	n/a
220	4	class Bitand(Node):
221	2	def __init__(self, nodes, lineno=None):
222	1	self.nodes = nodes
223	1	self.lineno = lineno
224	n/a
225	2	def getChildren(self):
226	0	return tuple(flatten(self.nodes))
227	n/a
228	2	def getChildNodes(self):
229	5	nodelist = []
230	5	nodelist.extend(flatten_nodes(self.nodes))
231	5	return tuple(nodelist)
232	n/a
233	2	def __repr__(self):
234	0	return "Bitand(%s)" % (repr(self.nodes),)
235	n/a
236	4	class Bitor(Node):
237	2	def __init__(self, nodes, lineno=None):
238	1	self.nodes = nodes
239	1	self.lineno = lineno
240	n/a
241	2	def getChildren(self):
242	0	return tuple(flatten(self.nodes))
243	n/a
244	2	def getChildNodes(self):
245	5	nodelist = []
246	5	nodelist.extend(flatten_nodes(self.nodes))
247	5	return tuple(nodelist)
248	n/a
249	2	def __repr__(self):
250	0	return "Bitor(%s)" % (repr(self.nodes),)
251	n/a
252	4	class Bitxor(Node):
253	2	def __init__(self, nodes, lineno=None):
254	1	self.nodes = nodes
255	1	self.lineno = lineno
256	n/a
257	2	def getChildren(self):
258	0	return tuple(flatten(self.nodes))
259	n/a
260	2	def getChildNodes(self):
261	5	nodelist = []
262	5	nodelist.extend(flatten_nodes(self.nodes))
263	5	return tuple(nodelist)
264	n/a
265	2	def __repr__(self):
266	0	return "Bitxor(%s)" % (repr(self.nodes),)
267	n/a
268	4	class Break(Node):
269	2	def __init__(self, lineno=None):
270	0	self.lineno = lineno
271	n/a
272	2	def getChildren(self):
273	0	return ()
274	n/a
275	2	def getChildNodes(self):
276	0	return ()
277	n/a
278	2	def __repr__(self):
279	0	return "Break()"
280	n/a
281	4	class CallFunc(Node):
282	2	def __init__(self, node, args, star_args = None, dstar_args = None, lineno=None):
283	3067	self.node = node
284	3067	self.args = args
285	3067	self.star_args = star_args
286	3067	self.dstar_args = dstar_args
287	3067	self.lineno = lineno
288	n/a
289	2	def getChildren(self):
290	0	children = []
291	0	children.append(self.node)
292	0	children.extend(flatten(self.args))
293	0	children.append(self.star_args)
294	0	children.append(self.dstar_args)
295	0	return tuple(children)
296	n/a
297	2	def getChildNodes(self):
298	14398	nodelist = []
299	14398	nodelist.append(self.node)
300	14398	nodelist.extend(flatten_nodes(self.args))
301	14398	if self.star_args is not None:
302	54	nodelist.append(self.star_args)
303	14398	if self.dstar_args is not None:
304	45	nodelist.append(self.dstar_args)
305	14398	return tuple(nodelist)
306	n/a
307	2	def __repr__(self):
308	0	return "CallFunc(%s, %s, %s, %s)" % (repr(self.node), repr(self.args), repr(self.star_args), repr(self.dstar_args))
309	n/a
310	4	class Class(Node):
311	2	def __init__(self, name, bases, doc, code, decorators = None, lineno=None):
312	395	self.name = name
313	395	self.bases = bases
314	395	self.doc = doc
315	395	self.code = code
316	395	self.decorators = decorators
317	395	self.lineno = lineno
318	n/a
319	2	def getChildren(self):
320	0	children = []
321	0	children.append(self.name)
322	0	children.extend(flatten(self.bases))
323	0	children.append(self.doc)
324	0	children.append(self.code)
325	0	children.append(self.decorators)
326	0	return tuple(children)
327	n/a
328	2	def getChildNodes(self):
329	1177	nodelist = []
330	1177	nodelist.extend(flatten_nodes(self.bases))
331	1177	nodelist.append(self.code)
332	1177	if self.decorators is not None:
333	0	nodelist.append(self.decorators)
334	1177	return tuple(nodelist)
335	n/a
336	2	def __repr__(self):
337	0	return "Class(%s, %s, %s, %s, %s)" % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code), repr(self.decorators))
338	n/a
339	4	class Compare(Node):
340	2	def __init__(self, expr, ops, lineno=None):
341	239	self.expr = expr
342	239	self.ops = ops
343	239	self.lineno = lineno
344	n/a
345	2	def getChildren(self):
346	0	children = []
347	0	children.append(self.expr)
348	0	children.extend(flatten(self.ops))
349	0	return tuple(children)
350	n/a
351	2	def getChildNodes(self):
352	1155	nodelist = []
353	1155	nodelist.append(self.expr)
354	1155	nodelist.extend(flatten_nodes(self.ops))
355	1155	return tuple(nodelist)
356	n/a
357	2	def __repr__(self):
358	0	return "Compare(%s, %s)" % (repr(self.expr), repr(self.ops))
359	n/a
360	4	class Const(Node):
361	2	def __init__(self, value, lineno=None):
362	3503	self.value = value
363	3503	self.lineno = lineno
364	n/a
365	2	def getChildren(self):
366	0	return self.value,
367	n/a
368	2	def getChildNodes(self):
369	15252	return ()
370	n/a
371	2	def __repr__(self):
372	0	return "Const(%s)" % (repr(self.value),)
373	n/a
374	4	class Continue(Node):
375	2	def __init__(self, lineno=None):
376	5	self.lineno = lineno
377	n/a
378	2	def getChildren(self):
379	0	return ()
380	n/a
381	2	def getChildNodes(self):
382	17	return ()
383	n/a
384	2	def __repr__(self):
385	0	return "Continue()"
386	n/a
387	4	class Decorators(Node):
388	2	def __init__(self, nodes, lineno=None):
389	19	self.nodes = nodes
390	19	self.lineno = lineno
391	n/a
392	2	def getChildren(self):
393	0	return tuple(flatten(self.nodes))
394	n/a
395	2	def getChildNodes(self):
396	76	nodelist = []
397	76	nodelist.extend(flatten_nodes(self.nodes))
398	76	return tuple(nodelist)
399	n/a
400	2	def __repr__(self):
401	0	return "Decorators(%s)" % (repr(self.nodes),)
402	n/a
403	4	class Dict(Node):
404	2	def __init__(self, items, lineno=None):
405	119	self.items = items
406	119	self.lineno = lineno
407	n/a
408	2	def getChildren(self):
409	0	return tuple(flatten(self.items))
410	n/a
411	2	def getChildNodes(self):
412	375	nodelist = []
413	375	nodelist.extend(flatten_nodes(self.items))
414	375	return tuple(nodelist)
415	n/a
416	2	def __repr__(self):
417	0	return "Dict(%s)" % (repr(self.items),)
418	n/a
419	4	class Discard(Node):
420	2	def __init__(self, expr, lineno=None):
421	1594	self.expr = expr
422	1594	self.lineno = lineno
423	n/a
424	2	def getChildren(self):
425	0	return self.expr,
426	n/a
427	2	def getChildNodes(self):
428	7625	return self.expr,
429	n/a
430	2	def __repr__(self):
431	0	return "Discard(%s)" % (repr(self.expr),)
432	n/a
433	4	class Div(Node):
434	2	def __init__(self, leftright, lineno=None):
435	4	self.left = leftright[0]
436	4	self.right = leftright[1]
437	4	self.lineno = lineno
438	n/a
439	2	def getChildren(self):
440	0	return self.left, self.right
441	n/a
442	2	def getChildNodes(self):
443	19	return self.left, self.right
444	n/a
445	2	def __repr__(self):
446	0	return "Div((%s, %s))" % (repr(self.left), repr(self.right))
447	n/a
448	4	class Ellipsis(Node):
449	2	def __init__(self, lineno=None):
450	0	self.lineno = lineno
451	n/a
452	2	def getChildren(self):
453	0	return ()
454	n/a
455	2	def getChildNodes(self):
456	0	return ()
457	n/a
458	2	def __repr__(self):
459	0	return "Ellipsis()"
460	n/a
461	4	class Exec(Node):
462	2	def __init__(self, expr, locals, globals, lineno=None):
463	18	self.expr = expr
464	18	self.locals = locals
465	18	self.globals = globals
466	18	self.lineno = lineno
467	n/a
468	2	def getChildren(self):
469	0	children = []
470	0	children.append(self.expr)
471	0	children.append(self.locals)
472	0	children.append(self.globals)
473	0	return tuple(children)
474	n/a
475	2	def getChildNodes(self):
476	54	nodelist = []
477	54	nodelist.append(self.expr)
478	54	if self.locals is not None:
479	39	nodelist.append(self.locals)
480	54	if self.globals is not None:
481	1	nodelist.append(self.globals)
482	54	return tuple(nodelist)
483	n/a
484	2	def __repr__(self):
485	0	return "Exec(%s, %s, %s)" % (repr(self.expr), repr(self.locals), repr(self.globals))
486	n/a
487	4	class FloorDiv(Node):
488	2	def __init__(self, leftright, lineno=None):
489	13	self.left = leftright[0]
490	13	self.right = leftright[1]
491	13	self.lineno = lineno
492	n/a
493	2	def getChildren(self):
494	0	return self.left, self.right
495	n/a
496	2	def getChildNodes(self):
497	64	return self.left, self.right
498	n/a
499	2	def __repr__(self):
500	0	return "FloorDiv((%s, %s))" % (repr(self.left), repr(self.right))
501	n/a
502	4	class For(Node):
503	2	def __init__(self, assign, list, body, else_, lineno=None):
504	93	self.assign = assign
505	93	self.list = list
506	93	self.body = body
507	93	self.else_ = else_
508	93	self.lineno = lineno
509	n/a
510	2	def getChildren(self):
511	0	children = []
512	0	children.append(self.assign)
513	0	children.append(self.list)
514	0	children.append(self.body)
515	0	children.append(self.else_)
516	0	return tuple(children)
517	n/a
518	2	def getChildNodes(self):
519	363	nodelist = []
520	363	nodelist.append(self.assign)
521	363	nodelist.append(self.list)
522	363	nodelist.append(self.body)
523	363	if self.else_ is not None:
524	0	nodelist.append(self.else_)
525	363	return tuple(nodelist)
526	n/a
527	2	def __repr__(self):
528	0	return "For(%s, %s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.body), repr(self.else_))
529	n/a
530	4	class From(Node):
531	2	def __init__(self, modname, names, level, lineno=None):
532	19	self.modname = modname
533	19	self.names = names
534	19	self.level = level
535	19	self.lineno = lineno
536	n/a
537	2	def getChildren(self):
538	0	return self.modname, self.names, self.level
539	n/a
540	2	def getChildNodes(self):
541	34	return ()
542	n/a
543	2	def __repr__(self):
544	0	return "From(%s, %s, %s)" % (repr(self.modname), repr(self.names), repr(self.level))
545	n/a
546	4	class Function(Node):
547	2	def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno=None):
548	648	self.decorators = decorators
549	648	self.name = name
550	648	self.argnames = argnames
551	648	self.defaults = defaults
552	648	self.flags = flags
553	648	self.doc = doc
554	648	self.code = code
555	648	self.lineno = lineno
556	648	self.varargs = self.kwargs = None
557	648	if flags & CO_VARARGS:
558	26	self.varargs = 1
559	648	if flags & CO_VARKEYWORDS:
560	5	self.kwargs = 1
561	n/a
562	n/a
563	2	def getChildren(self):
564	0	children = []
565	0	children.append(self.decorators)
566	0	children.append(self.name)
567	0	children.append(self.argnames)
568	0	children.extend(flatten(self.defaults))
569	0	children.append(self.flags)
570	0	children.append(self.doc)
571	0	children.append(self.code)
572	0	return tuple(children)
573	n/a
574	2	def getChildNodes(self):
575	1882	nodelist = []
576	1882	if self.decorators is not None:
577	57	nodelist.append(self.decorators)
578	1882	nodelist.extend(flatten_nodes(self.defaults))
579	1882	nodelist.append(self.code)
580	1882	return tuple(nodelist)
581	n/a
582	2	def __repr__(self):
583	0	return "Function(%s, %s, %s, %s, %s, %s, %s)" % (repr(self.decorators), repr(self.name), repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.doc), repr(self.code))
584	n/a
585	4	class GenExpr(Node):
586	2	def __init__(self, code, lineno=None):
587	2	self.code = code
588	2	self.lineno = lineno
589	2	self.argnames = ['.0']
590	2	self.varargs = self.kwargs = None
591	n/a
592	n/a
593	2	def getChildren(self):
594	0	return self.code,
595	n/a
596	2	def getChildNodes(self):
597	6	return self.code,
598	n/a
599	2	def __repr__(self):
600	0	return "GenExpr(%s)" % (repr(self.code),)
601	n/a
602	4	class GenExprFor(Node):
603	2	def __init__(self, assign, iter, ifs, lineno=None):
604	3	self.assign = assign
605	3	self.iter = iter
606	3	self.ifs = ifs
607	3	self.lineno = lineno
608	3	self.is_outmost = False
609	n/a
610	2	def getChildren(self):
611	0	children = []
612	0	children.append(self.assign)
613	0	children.append(self.iter)
614	0	children.extend(flatten(self.ifs))
615	0	return tuple(children)
616	n/a
617	2	def getChildNodes(self):
618	11	nodelist = []
619	11	nodelist.append(self.assign)
620	11	nodelist.append(self.iter)
621	11	nodelist.extend(flatten_nodes(self.ifs))
622	11	return tuple(nodelist)
623	n/a
624	2	def __repr__(self):
625	0	return "GenExprFor(%s, %s, %s)" % (repr(self.assign), repr(self.iter), repr(self.ifs))
626	n/a
627	4	class GenExprIf(Node):
628	2	def __init__(self, test, lineno=None):
629	2	self.test = test
630	2	self.lineno = lineno
631	n/a
632	2	def getChildren(self):
633	0	return self.test,
634	n/a
635	2	def getChildNodes(self):
636	6	return self.test,
637	n/a
638	2	def __repr__(self):
639	0	return "GenExprIf(%s)" % (repr(self.test),)
640	n/a
641	4	class GenExprInner(Node):
642	2	def __init__(self, expr, quals, lineno=None):
643	2	self.expr = expr
644	2	self.quals = quals
645	2	self.lineno = lineno
646	n/a
647	2	def getChildren(self):
648	0	children = []
649	0	children.append(self.expr)
650	0	children.extend(flatten(self.quals))
651	0	return tuple(children)
652	n/a
653	2	def getChildNodes(self):
654	8	nodelist = []
655	8	nodelist.append(self.expr)
656	8	nodelist.extend(flatten_nodes(self.quals))
657	8	return tuple(nodelist)
658	n/a
659	2	def __repr__(self):
660	0	return "GenExprInner(%s, %s)" % (repr(self.expr), repr(self.quals))
661	n/a
662	4	class Getattr(Node):
663	2	def __init__(self, expr, attrname, lineno=None):
664	2658	self.expr = expr
665	2658	self.attrname = attrname
666	2658	self.lineno = lineno
667	n/a
668	2	def getChildren(self):
669	0	return self.expr, self.attrname
670	n/a
671	2	def getChildNodes(self):
672	12507	return self.expr,
673	n/a
674	2	def __repr__(self):
675	0	return "Getattr(%s, %s)" % (repr(self.expr), repr(self.attrname))
676	n/a
677	4	class Global(Node):
678	2	def __init__(self, names, lineno=None):
679	8	self.names = names
680	8	self.lineno = lineno
681	n/a
682	2	def getChildren(self):
683	0	return self.names,
684	n/a
685	2	def getChildNodes(self):
686	22	return ()
687	n/a
688	2	def __repr__(self):
689	0	return "Global(%s)" % (repr(self.names),)
690	n/a
691	4	class If(Node):
692	2	def __init__(self, tests, else_, lineno=None):
693	125	self.tests = tests
694	125	self.else_ = else_
695	125	self.lineno = lineno
696	n/a
697	2	def getChildren(self):
698	0	children = []
699	0	children.extend(flatten(self.tests))
700	0	children.append(self.else_)
701	0	return tuple(children)
702	n/a
703	2	def getChildNodes(self):
704	473	nodelist = []
705	473	nodelist.extend(flatten_nodes(self.tests))
706	473	if self.else_ is not None:
707	106	nodelist.append(self.else_)
708	473	return tuple(nodelist)
709	n/a
710	2	def __repr__(self):
711	0	return "If(%s, %s)" % (repr(self.tests), repr(self.else_))
712	n/a
713	4	class IfExp(Node):
714	2	def __init__(self, test, then, else_, lineno=None):
715	0	self.test = test
716	0	self.then = then
717	0	self.else_ = else_
718	0	self.lineno = lineno
719	n/a
720	2	def getChildren(self):
721	0	return self.test, self.then, self.else_
722	n/a
723	2	def getChildNodes(self):
724	0	return self.test, self.then, self.else_
725	n/a
726	2	def __repr__(self):
727	0	return "IfExp(%s, %s, %s)" % (repr(self.test), repr(self.then), repr(self.else_))
728	n/a
729	4	class Import(Node):
730	2	def __init__(self, names, lineno=None):
731	50	self.names = names
732	50	self.lineno = lineno
733	n/a
734	2	def getChildren(self):
735	0	return self.names,
736	n/a
737	2	def getChildNodes(self):
738	146	return ()
739	n/a
740	2	def __repr__(self):
741	0	return "Import(%s)" % (repr(self.names),)
742	n/a
743	4	class Invert(Node):
744	2	def __init__(self, expr, lineno=None):
745	0	self.expr = expr
746	0	self.lineno = lineno
747	n/a
748	2	def getChildren(self):
749	0	return self.expr,
750	n/a
751	2	def getChildNodes(self):
752	0	return self.expr,
753	n/a
754	2	def __repr__(self):
755	0	return "Invert(%s)" % (repr(self.expr),)
756	n/a
757	4	class Keyword(Node):
758	2	def __init__(self, name, expr, lineno=None):
759	41	self.name = name
760	41	self.expr = expr
761	41	self.lineno = lineno
762	n/a
763	2	def getChildren(self):
764	0	return self.name, self.expr
765	n/a
766	2	def getChildNodes(self):
767	186	return self.expr,
768	n/a
769	2	def __repr__(self):
770	0	return "Keyword(%s, %s)" % (repr(self.name), repr(self.expr))
771	n/a
772	4	class Lambda(Node):
773	2	def __init__(self, argnames, defaults, flags, code, lineno=None):
774	18	self.argnames = argnames
775	18	self.defaults = defaults
776	18	self.flags = flags
777	18	self.code = code
778	18	self.lineno = lineno
779	18	self.varargs = self.kwargs = None
780	18	if flags & CO_VARARGS:
781	1	self.varargs = 1
782	18	if flags & CO_VARKEYWORDS:
783	0	self.kwargs = 1
784	n/a
785	n/a
786	2	def getChildren(self):
787	0	children = []
788	0	children.append(self.argnames)
789	0	children.extend(flatten(self.defaults))
790	0	children.append(self.flags)
791	0	children.append(self.code)
792	0	return tuple(children)
793	n/a
794	2	def getChildNodes(self):
795	36	nodelist = []
796	36	nodelist.extend(flatten_nodes(self.defaults))
797	36	nodelist.append(self.code)
798	36	return tuple(nodelist)
799	n/a
800	2	def __repr__(self):
801	0	return "Lambda(%s, %s, %s, %s)" % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code))
802	n/a
803	4	class LeftShift(Node):
804	2	def __init__(self, leftright, lineno=None):
805	6	self.left = leftright[0]
806	6	self.right = leftright[1]
807	6	self.lineno = lineno
808	n/a
809	2	def getChildren(self):
810	0	return self.left, self.right
811	n/a
812	2	def getChildNodes(self):
813	30	return self.left, self.right
814	n/a
815	2	def __repr__(self):
816	0	return "LeftShift((%s, %s))" % (repr(self.left), repr(self.right))
817	n/a
818	4	class List(Node):
819	2	def __init__(self, nodes, lineno=None):
820	323	self.nodes = nodes
821	323	self.lineno = lineno
822	n/a
823	2	def getChildren(self):
824	0	return tuple(flatten(self.nodes))
825	n/a
826	2	def getChildNodes(self):
827	1452	nodelist = []
828	1452	nodelist.extend(flatten_nodes(self.nodes))
829	1452	return tuple(nodelist)
830	n/a
831	2	def __repr__(self):
832	0	return "List(%s)" % (repr(self.nodes),)
833	n/a
834	4	class ListComp(Node):
835	2	def __init__(self, expr, quals, lineno=None):
836	14	self.expr = expr
837	14	self.quals = quals
838	14	self.lineno = lineno
839	n/a
840	2	def getChildren(self):
841	0	children = []
842	0	children.append(self.expr)
843	0	children.extend(flatten(self.quals))
844	0	return tuple(children)
845	n/a
846	2	def getChildNodes(self):
847	58	nodelist = []
848	58	nodelist.append(self.expr)
849	58	nodelist.extend(flatten_nodes(self.quals))
850	58	return tuple(nodelist)
851	n/a
852	2	def __repr__(self):
853	0	return "ListComp(%s, %s)" % (repr(self.expr), repr(self.quals))
854	n/a
855	4	class ListCompFor(Node):
856	2	def __init__(self, assign, list, ifs, lineno=None):
857	22	self.assign = assign
858	22	self.list = list
859	22	self.ifs = ifs
860	22	self.lineno = lineno
861	n/a
862	2	def getChildren(self):
863	0	children = []
864	0	children.append(self.assign)
865	0	children.append(self.list)
866	0	children.extend(flatten(self.ifs))
867	0	return tuple(children)
868	n/a
869	2	def getChildNodes(self):
870	78	nodelist = []
871	78	nodelist.append(self.assign)
872	78	nodelist.append(self.list)
873	78	nodelist.extend(flatten_nodes(self.ifs))
874	78	return tuple(nodelist)
875	n/a
876	2	def __repr__(self):
877	0	return "ListCompFor(%s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.ifs))
878	n/a
879	4	class ListCompIf(Node):
880	2	def __init__(self, test, lineno=None):
881	8	self.test = test
882	8	self.lineno = lineno
883	n/a
884	2	def getChildren(self):
885	0	return self.test,
886	n/a
887	2	def getChildNodes(self):
888	30	return self.test,
889	n/a
890	2	def __repr__(self):
891	0	return "ListCompIf(%s)" % (repr(self.test),)
892	n/a
893	4	class SetComp(Node):
894	2	def __init__(self, expr, quals, lineno=None):
895	3	self.expr = expr
896	3	self.quals = quals
897	3	self.lineno = lineno
898	n/a
899	2	def getChildren(self):
900	0	children = []
901	0	children.append(self.expr)
902	0	children.extend(flatten(self.quals))
903	0	return tuple(children)
904	n/a
905	2	def getChildNodes(self):
906	7	nodelist = []
907	7	nodelist.append(self.expr)
908	7	nodelist.extend(flatten_nodes(self.quals))
909	7	return tuple(nodelist)
910	n/a
911	2	def __repr__(self):
912	0	return "SetComp(%s, %s)" % (repr(self.expr), repr(self.quals))
913	n/a
914	4	class DictComp(Node):
915	2	def __init__(self, key, value, quals, lineno=None):
916	3	self.key = key
917	3	self.value = value
918	3	self.quals = quals
919	3	self.lineno = lineno
920	n/a
921	2	def getChildren(self):
922	0	children = []
923	0	children.append(self.key)
924	0	children.append(self.value)
925	0	children.extend(flatten(self.quals))
926	0	return tuple(children)
927	n/a
928	2	def getChildNodes(self):
929	7	nodelist = []
930	7	nodelist.append(self.key)
931	7	nodelist.append(self.value)
932	7	nodelist.extend(flatten_nodes(self.quals))
933	7	return tuple(nodelist)
934	n/a
935	2	def __repr__(self):
936	0	return "DictComp(%s, %s, %s)" % (repr(self.key), repr(self.value), repr(self.quals))
937	n/a
938	4	class Mod(Node):
939	2	def __init__(self, leftright, lineno=None):
940	81	self.left = leftright[0]
941	81	self.right = leftright[1]
942	81	self.lineno = lineno
943	n/a
944	2	def getChildren(self):
945	0	return self.left, self.right
946	n/a
947	2	def getChildNodes(self):
948	388	return self.left, self.right
949	n/a
950	2	def __repr__(self):
951	0	return "Mod((%s, %s))" % (repr(self.left), repr(self.right))
952	n/a
953	4	class Module(Node):
954	2	def __init__(self, doc, node, lineno=None):
955	26	self.doc = doc
956	26	self.node = node
957	26	self.lineno = lineno
958	n/a
959	2	def getChildren(self):
960	0	return self.doc, self.node
961	n/a
962	2	def getChildNodes(self):
963	67	return self.node,
964	n/a
965	2	def __repr__(self):
966	0	return "Module(%s, %s)" % (repr(self.doc), repr(self.node))
967	n/a
968	4	class Mul(Node):
969	2	def __init__(self, leftright, lineno=None):
970	47	self.left = leftright[0]
971	47	self.right = leftright[1]
972	47	self.lineno = lineno
973	n/a
974	2	def getChildren(self):
975	0	return self.left, self.right
976	n/a
977	2	def getChildNodes(self):
978	224	return self.left, self.right
979	n/a
980	2	def __repr__(self):
981	0	return "Mul((%s, %s))" % (repr(self.left), repr(self.right))
982	n/a
983	4	class Name(Node):
984	2	def __init__(self, name, lineno=None):
985	7060	self.name = name
986	7060	self.lineno = lineno
987	n/a
988	2	def getChildren(self):
989	0	return self.name,
990	n/a
991	2	def getChildNodes(self):
992	25562	return ()
993	n/a
994	2	def __repr__(self):
995	0	return "Name(%s)" % (repr(self.name),)
996	n/a
997	4	class Not(Node):
998	2	def __init__(self, expr, lineno=None):
999	34	self.expr = expr
1000	34	self.lineno = lineno
1001	n/a
1002	2	def getChildren(self):
1003	0	return self.expr,
1004	n/a
1005	2	def getChildNodes(self):
1006	158	return self.expr,
1007	n/a
1008	2	def __repr__(self):
1009	0	return "Not(%s)" % (repr(self.expr),)
1010	n/a
1011	4	class Or(Node):
1012	2	def __init__(self, nodes, lineno=None):
1013	9	self.nodes = nodes
1014	9	self.lineno = lineno
1015	n/a
1016	2	def getChildren(self):
1017	0	return tuple(flatten(self.nodes))
1018	n/a
1019	2	def getChildNodes(self):
1020	40	nodelist = []
1021	40	nodelist.extend(flatten_nodes(self.nodes))
1022	40	return tuple(nodelist)
1023	n/a
1024	2	def __repr__(self):
1025	0	return "Or(%s)" % (repr(self.nodes),)
1026	n/a
1027	4	class Pass(Node):
1028	2	def __init__(self, lineno=None):
1029	266	self.lineno = lineno
1030	n/a
1031	2	def getChildren(self):
1032	0	return ()
1033	n/a
1034	2	def getChildNodes(self):
1035	1314	return ()
1036	n/a
1037	2	def __repr__(self):
1038	0	return "Pass()"
1039	n/a
1040	4	class Power(Node):
1041	2	def __init__(self, leftright, lineno=None):
1042	4	self.left = leftright[0]
1043	4	self.right = leftright[1]
1044	4	self.lineno = lineno
1045	n/a
1046	2	def getChildren(self):
1047	0	return self.left, self.right
1048	n/a
1049	2	def getChildNodes(self):
1050	20	return self.left, self.right
1051	n/a
1052	2	def __repr__(self):
1053	0	return "Power((%s, %s))" % (repr(self.left), repr(self.right))
1054	n/a
1055	4	class Print(Node):
1056	2	def __init__(self, nodes, dest, lineno=None):
1057	0	self.nodes = nodes
1058	0	self.dest = dest
1059	0	self.lineno = lineno
1060	n/a
1061	2	def getChildren(self):
1062	0	children = []
1063	0	children.extend(flatten(self.nodes))
1064	0	children.append(self.dest)
1065	0	return tuple(children)
1066	n/a
1067	2	def getChildNodes(self):
1068	0	nodelist = []
1069	0	nodelist.extend(flatten_nodes(self.nodes))
1070	0	if self.dest is not None:
1071	0	nodelist.append(self.dest)
1072	0	return tuple(nodelist)
1073	n/a
1074	2	def __repr__(self):
1075	0	return "Print(%s, %s)" % (repr(self.nodes), repr(self.dest))
1076	n/a
1077	4	class Printnl(Node):
1078	2	def __init__(self, nodes, dest, lineno=None):
1079	12	self.nodes = nodes
1080	12	self.dest = dest
1081	12	self.lineno = lineno
1082	n/a
1083	2	def getChildren(self):
1084	0	children = []
1085	0	children.extend(flatten(self.nodes))
1086	0	children.append(self.dest)
1087	0	return tuple(children)
1088	n/a
1089	2	def getChildNodes(self):
1090	44	nodelist = []
1091	44	nodelist.extend(flatten_nodes(self.nodes))
1092	44	if self.dest is not None:
1093	21	nodelist.append(self.dest)
1094	44	return tuple(nodelist)
1095	n/a
1096	2	def __repr__(self):
1097	0	return "Printnl(%s, %s)" % (repr(self.nodes), repr(self.dest))
1098	n/a
1099	4	class Raise(Node):
1100	2	def __init__(self, expr1, expr2, expr3, lineno=None):
1101	30	self.expr1 = expr1
1102	30	self.expr2 = expr2
1103	30	self.expr3 = expr3
1104	30	self.lineno = lineno
1105	n/a
1106	2	def getChildren(self):
1107	0	children = []
1108	0	children.append(self.expr1)
1109	0	children.append(self.expr2)
1110	0	children.append(self.expr3)
1111	0	return tuple(children)
1112	n/a
1113	2	def getChildNodes(self):
1114	142	nodelist = []
1115	142	if self.expr1 is not None:
1116	135	nodelist.append(self.expr1)
1117	142	if self.expr2 is not None:
1118	60	nodelist.append(self.expr2)
1119	142	if self.expr3 is not None:
1120	0	nodelist.append(self.expr3)
1121	142	return tuple(nodelist)
1122	n/a
1123	2	def __repr__(self):
1124	0	return "Raise(%s, %s, %s)" % (repr(self.expr1), repr(self.expr2), repr(self.expr3))
1125	n/a
1126	4	class Return(Node):
1127	2	def __init__(self, value, lineno=None):
1128	281	self.value = value
1129	281	self.lineno = lineno
1130	n/a
1131	2	def getChildren(self):
1132	0	return self.value,
1133	n/a
1134	2	def getChildNodes(self):
1135	1401	return self.value,
1136	n/a
1137	2	def __repr__(self):
1138	0	return "Return(%s)" % (repr(self.value),)
1139	n/a
1140	4	class RightShift(Node):
1141	2	def __init__(self, leftright, lineno=None):
1142	4	self.left = leftright[0]
1143	4	self.right = leftright[1]
1144	4	self.lineno = lineno
1145	n/a
1146	2	def getChildren(self):
1147	0	return self.left, self.right
1148	n/a
1149	2	def getChildNodes(self):
1150	20	return self.left, self.right
1151	n/a
1152	2	def __repr__(self):
1153	0	return "RightShift((%s, %s))" % (repr(self.left), repr(self.right))
1154	n/a
1155	4	class Set(Node):
1156	2	def __init__(self, nodes, lineno=None):
1157	7	self.nodes = nodes
1158	7	self.lineno = lineno
1159	n/a
1160	2	def getChildren(self):
1161	0	return tuple(flatten(self.nodes))
1162	n/a
1163	2	def getChildNodes(self):
1164	11	nodelist = []
1165	11	nodelist.extend(flatten_nodes(self.nodes))
1166	11	return tuple(nodelist)
1167	n/a
1168	2	def __repr__(self):
1169	0	return "Set(%s)" % (repr(self.nodes),)
1170	n/a
1171	4	class Slice(Node):
1172	2	def __init__(self, expr, flags, lower, upper, lineno=None):
1173	36	self.expr = expr
1174	36	self.flags = flags
1175	36	self.lower = lower
1176	36	self.upper = upper
1177	36	self.lineno = lineno
1178	n/a
1179	2	def getChildren(self):
1180	0	children = []
1181	0	children.append(self.expr)
1182	0	children.append(self.flags)
1183	0	children.append(self.lower)
1184	0	children.append(self.upper)
1185	0	return tuple(children)
1186	n/a
1187	2	def getChildNodes(self):
1188	126	nodelist = []
1189	126	nodelist.append(self.expr)
1190	126	if self.lower is not None:
1191	63	nodelist.append(self.lower)
1192	126	if self.upper is not None:
1193	78	nodelist.append(self.upper)
1194	126	return tuple(nodelist)
1195	n/a
1196	2	def __repr__(self):
1197	0	return "Slice(%s, %s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.upper))
1198	n/a
1199	4	class Sliceobj(Node):
1200	2	def __init__(self, nodes, lineno=None):
1201	0	self.nodes = nodes
1202	0	self.lineno = lineno
1203	n/a
1204	2	def getChildren(self):
1205	0	return tuple(flatten(self.nodes))
1206	n/a
1207	2	def getChildNodes(self):
1208	0	nodelist = []
1209	0	nodelist.extend(flatten_nodes(self.nodes))
1210	0	return tuple(nodelist)
1211	n/a
1212	2	def __repr__(self):
1213	0	return "Sliceobj(%s)" % (repr(self.nodes),)
1214	n/a
1215	4	class Stmt(Node):
1216	2	def __init__(self, nodes, lineno=None):
1217	9833	self.nodes = nodes
1218	9833	self.lineno = lineno
1219	n/a
1220	2	def getChildren(self):
1221	0	return tuple(flatten(self.nodes))
1222	n/a
1223	2	def getChildNodes(self):
1224	10069	nodelist = []
1225	10069	nodelist.extend(flatten_nodes(self.nodes))
1226	10069	return tuple(nodelist)
1227	n/a
1228	2	def __repr__(self):
1229	0	return "Stmt(%s)" % (repr(self.nodes),)
1230	n/a
1231	4	class Sub(Node):
1232	2	def __init__(self, leftright, lineno=None):
1233	5	self.left = leftright[0]
1234	5	self.right = leftright[1]
1235	5	self.lineno = lineno
1236	n/a
1237	2	def getChildren(self):
1238	0	return self.left, self.right
1239	n/a
1240	2	def getChildNodes(self):
1241	24	return self.left, self.right
1242	n/a
1243	2	def __repr__(self):
1244	0	return "Sub((%s, %s))" % (repr(self.left), repr(self.right))
1245	n/a
1246	4	class Subscript(Node):
1247	2	def __init__(self, expr, flags, subs, lineno=None):
1248	151	self.expr = expr
1249	151	self.flags = flags
1250	151	self.subs = subs
1251	151	self.lineno = lineno
1252	n/a
1253	2	def getChildren(self):
1254	0	children = []
1255	0	children.append(self.expr)
1256	0	children.append(self.flags)
1257	0	children.extend(flatten(self.subs))
1258	0	return tuple(children)
1259	n/a
1260	2	def getChildNodes(self):
1261	522	nodelist = []
1262	522	nodelist.append(self.expr)
1263	522	nodelist.extend(flatten_nodes(self.subs))
1264	522	return tuple(nodelist)
1265	n/a
1266	2	def __repr__(self):
1267	0	return "Subscript(%s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.subs))
1268	n/a
1269	4	class TryExcept(Node):
1270	2	def __init__(self, body, handlers, else_, lineno=None):
1271	136	self.body = body
1272	136	self.handlers = handlers
1273	136	self.else_ = else_
1274	136	self.lineno = lineno
1275	n/a
1276	2	def getChildren(self):
1277	0	children = []
1278	0	children.append(self.body)
1279	0	children.extend(flatten(self.handlers))
1280	0	children.append(self.else_)
1281	0	return tuple(children)
1282	n/a
1283	2	def getChildNodes(self):
1284	664	nodelist = []
1285	664	nodelist.append(self.body)
1286	664	nodelist.extend(flatten_nodes(self.handlers))
1287	664	if self.else_ is not None:
1288	491	nodelist.append(self.else_)
1289	664	return tuple(nodelist)
1290	n/a
1291	2	def __repr__(self):
1292	0	return "TryExcept(%s, %s, %s)" % (repr(self.body), repr(self.handlers), repr(self.else_))
1293	n/a
1294	4	class TryFinally(Node):
1295	2	def __init__(self, body, final, lineno=None):
1296	13	self.body = body
1297	13	self.final = final
1298	13	self.lineno = lineno
1299	n/a
1300	2	def getChildren(self):
1301	0	return self.body, self.final
1302	n/a
1303	2	def getChildNodes(self):
1304	61	return self.body, self.final
1305	n/a
1306	2	def __repr__(self):
1307	0	return "TryFinally(%s, %s)" % (repr(self.body), repr(self.final))
1308	n/a
1309	4	class Tuple(Node):
1310	2	def __init__(self, nodes, lineno=None):
1311	532	self.nodes = nodes
1312	532	self.lineno = lineno
1313	n/a
1314	2	def getChildren(self):
1315	0	return tuple(flatten(self.nodes))
1316	n/a
1317	2	def getChildNodes(self):
1318	2365	nodelist = []
1319	2365	nodelist.extend(flatten_nodes(self.nodes))
1320	2365	return tuple(nodelist)
1321	n/a
1322	2	def __repr__(self):
1323	0	return "Tuple(%s)" % (repr(self.nodes),)
1324	n/a
1325	4	class UnaryAdd(Node):
1326	2	def __init__(self, expr, lineno=None):
1327	4	self.expr = expr
1328	4	self.lineno = lineno
1329	n/a
1330	2	def getChildren(self):
1331	0	return self.expr,
1332	n/a
1333	2	def getChildNodes(self):
1334	20	return self.expr,
1335	n/a
1336	2	def __repr__(self):
1337	0	return "UnaryAdd(%s)" % (repr(self.expr),)
1338	n/a
1339	4	class UnarySub(Node):
1340	2	def __init__(self, expr, lineno=None):
1341	57	self.expr = expr
1342	57	self.lineno = lineno
1343	n/a
1344	2	def getChildren(self):
1345	0	return self.expr,
1346	n/a
1347	2	def getChildNodes(self):
1348	248	return self.expr,
1349	n/a
1350	2	def __repr__(self):
1351	0	return "UnarySub(%s)" % (repr(self.expr),)
1352	n/a
1353	4	class While(Node):
1354	2	def __init__(self, test, body, else_, lineno=None):
1355	12	self.test = test
1356	12	self.body = body
1357	12	self.else_ = else_
1358	12	self.lineno = lineno
1359	n/a
1360	2	def getChildren(self):
1361	0	children = []
1362	0	children.append(self.test)
1363	0	children.append(self.body)
1364	0	children.append(self.else_)
1365	0	return tuple(children)
1366	n/a
1367	2	def getChildNodes(self):
1368	60	nodelist = []
1369	60	nodelist.append(self.test)
1370	60	nodelist.append(self.body)
1371	60	if self.else_ is not None:
1372	0	nodelist.append(self.else_)
1373	60	return tuple(nodelist)
1374	n/a
1375	2	def __repr__(self):
1376	0	return "While(%s, %s, %s)" % (repr(self.test), repr(self.body), repr(self.else_))
1377	n/a
1378	4	class With(Node):
1379	2	def __init__(self, expr, vars, body, lineno=None):
1380	8	self.expr = expr
1381	8	self.vars = vars
1382	8	self.body = body
1383	8	self.lineno = lineno
1384	n/a
1385	2	def getChildren(self):
1386	0	children = []
1387	0	children.append(self.expr)
1388	0	children.append(self.vars)
1389	0	children.append(self.body)
1390	0	return tuple(children)
1391	n/a
1392	2	def getChildNodes(self):
1393	40	nodelist = []
1394	40	nodelist.append(self.expr)
1395	40	if self.vars is not None:
1396	20	nodelist.append(self.vars)
1397	40	nodelist.append(self.body)
1398	40	return tuple(nodelist)
1399	n/a
1400	2	def __repr__(self):
1401	0	return "With(%s, %s, %s)" % (repr(self.expr), repr(self.vars), repr(self.body))
1402	n/a
1403	4	class Yield(Node):
1404	2	def __init__(self, value, lineno=None):
1405	2	self.value = value
1406	2	self.lineno = lineno
1407	n/a
1408	2	def getChildren(self):
1409	0	return self.value,
1410	n/a
1411	2	def getChildNodes(self):
1412	8	return self.value,
1413	n/a
1414	2	def __repr__(self):
1415	0	return "Yield(%s)" % (repr(self.value),)
1416	n/a
1417	178	for name, obj in globals().items():
1418	176	if isinstance(obj, type) and issubclass(obj, Node):
1419	0	nodes[name.lower()] = obj