Mercurial Repositories > eric / file comparison

comparison: eric6/Plugins/CheckerPlugins/CodeStyleChecker/Simplify/ast_unparse.py

eric6/Plugins/CheckerPlugins/CodeStyleChecker/Simplify/ast_unparse.py

changeset 8186
655b658aa7ee
child 8201
a1149b1b4456
equal deleted inserted replaced
8185:c9acf46b54ce 8186:655b658aa7ee
1 """
2 ast_unparse
3 ~~~~~~~~~~~
4
5 This module is a backport of the unparse function of the Python 3.9
6 ast module.
7
8 Original ast module code is
9 :copyright: Copyright 2008 by Armin Ronacher.
10 :license: Python License.
11 """
12
13 import ast
14 import sys
15 from enum import IntEnum, auto
16 from contextlib import contextmanager, nullcontext
17
18 # Large float and imaginary literals get turned into infinities in the AST.
19 # We unparse those infinities to INFSTR.
20 _INFSTR = "1e" + repr(sys.float_info.max_10_exp + 1)
21
22 class _Precedence(IntEnum):
23 """Precedence table that originated from python grammar."""
24
25 TUPLE = auto()
26 YIELD = auto() # 'yield', 'yield from'
27 TEST = auto() # 'if'-'else', 'lambda'
28 OR = auto() # 'or'
29 AND = auto() # 'and'
30 NOT = auto() # 'not'
31 CMP = auto() # '<', '>', '==', '>=', '<=', '!=',
32 # 'in', 'not in', 'is', 'is not'
33 EXPR = auto()
34 BOR = EXPR # '|'
35 BXOR = auto() # '^'
36 BAND = auto() # '&'
37 SHIFT = auto() # '<<', '>>'
38 ARITH = auto() # '+', '-'
39 TERM = auto() # '*', '@', '/', '%', '//'
40 FACTOR = auto() # unary '+', '-', '~'
41 POWER = auto() # '**'
42 AWAIT = auto() # 'await'
43 ATOM = auto()
44
45 def next(self):
46 try:
47 return self.__class__(self + 1)
48 except ValueError:
49 return self
50
51
52 _SINGLE_QUOTES = ("'", '"')
53 _MULTI_QUOTES = ('"""', "'''")
54 _ALL_QUOTES = (*_SINGLE_QUOTES, *_MULTI_QUOTES)
55
56 class _Unparser(ast.NodeVisitor):
57 """Methods in this class recursively traverse an AST and
58 output source code for the abstract syntax; original formatting
59 is disregarded."""
60
61 def __init__(self, *, _avoid_backslashes=False):
62 self._source = []
63 self._buffer = []
64 self._precedences = {}
65 self._type_ignores = {}
66 self._indent = 0
67 self._avoid_backslashes = _avoid_backslashes
68
69 def interleave(self, inter, f, seq):
70 """Call f on each item in seq, calling inter() in between."""
71 seq = iter(seq)
72 try:
73 f(next(seq))
74 except StopIteration:
75 pass
76 else:
77 for x in seq:
78 inter()
79 f(x)
80
81 def items_view(self, traverser, items):
82 """Traverse and separate the given *items* with a comma and append it to
83 the buffer. If *items* is a single item sequence, a trailing comma
84 will be added."""
85 if len(items) == 1:
86 traverser(items[0])
87 self.write(",")
88 else:
89 self.interleave(lambda: self.write(", "), traverser, items)
90
91 def maybe_newline(self):
92 """Adds a newline if it isn't the start of generated source"""
93 if self._source:
94 self.write("\n")
95
96 def fill(self, text=""):
97 """Indent a piece of text and append it, according to the current
98 indentation level"""
99 self.maybe_newline()
100 self.write(" " * self._indent + text)
101
102 def write(self, text):
103 """Append a piece of text"""
104 self._source.append(text)
105
106 def buffer_writer(self, text):
107 self._buffer.append(text)
108
109 @property
110 def buffer(self):
111 value = "".join(self._buffer)
112 self._buffer.clear()
113 return value
114
115 @contextmanager
116 def block(self, *, extra = None):
117 """A context manager for preparing the source for blocks. It adds
118 the character':', increases the indentation on enter and decreases
119 the indentation on exit. If *extra* is given, it will be directly
120 appended after the colon character.
121 """
122 self.write(":")
123 if extra:
124 self.write(extra)
125 self._indent += 1
126 yield
127 self._indent -= 1
128
129 @contextmanager
130 def delimit(self, start, end):
131 """A context manager for preparing the source for expressions. It adds
132 *start* to the buffer and enters, after exit it adds *end*."""
133
134 self.write(start)
135 yield
136 self.write(end)
137
138 def delimit_if(self, start, end, condition):
139 if condition:
140 return self.delimit(start, end)
141 else:
142 return nullcontext()
143
144 def require_parens(self, precedence, node):
145 """Shortcut to adding precedence related parens"""
146 return self.delimit_if("(", ")", self.get_precedence(node) > precedence)
147
148 def get_precedence(self, node):
149 return self._precedences.get(node, _Precedence.TEST)
150
151 def set_precedence(self, precedence, *nodes):
152 for node in nodes:
153 self._precedences[node] = precedence
154
155 def get_raw_docstring(self, node):
156 """If a docstring node is found in the body of the *node* parameter,
157 return that docstring node, None otherwise.
158
159 Logic mirrored from ``_PyAST_GetDocString``."""
160 if not isinstance(
161 node, (ast.AsyncFunctionDef, ast.FunctionDef, ast.ClassDef,
162 ast.Module)
163 ) or len(node.body) < 1:
164 return None
165 node = node.body[0]
166 if not isinstance(node, ast.Expr):
167 return None
168 node = node.value
169 if isinstance(node, ast.Constant) and isinstance(node.value, str):
170 return node
171
172 def get_type_comment(self, node):
173 comment = self._type_ignores.get(node.lineno) or node.type_comment
174 if comment is not None:
175 return f" # type: {comment}"
176
177 def traverse(self, node):
178 if isinstance(node, list):
179 for item in node:
180 self.traverse(item)
181 else:
182 super().visit(node)
183
184 def visit(self, node):
185 """Outputs a source code string that, if converted back to an ast
186 (using ast.parse) will generate an AST equivalent to *node*"""
187 self._source = []
188 self.traverse(node)
189 return "".join(self._source)
190
191 def _write_docstring_and_traverse_body(self, node):
192 if (docstring := self.get_raw_docstring(node)):
193 self._write_docstring(docstring)
194 self.traverse(node.body[1:])
195 else:
196 self.traverse(node.body)
197
198 def visit_Module(self, node):
199 self._type_ignores = {
200 ignore.lineno: f"ignore{ignore.tag}"
201 for ignore in node.type_ignores
202 }
203 self._write_docstring_and_traverse_body(node)
204 self._type_ignores.clear()
205
206 def visit_FunctionType(self, node):
207 with self.delimit("(", ")"):
208 self.interleave(
209 lambda: self.write(", "), self.traverse, node.argtypes
210 )
211
212 self.write(" -> ")
213 self.traverse(node.returns)
214
215 def visit_Expr(self, node):
216 self.fill()
217 self.set_precedence(_Precedence.YIELD, node.value)
218 self.traverse(node.value)
219
220 def visit_NamedExpr(self, node):
221 with self.require_parens(_Precedence.TUPLE, node):
222 self.set_precedence(_Precedence.ATOM, node.target, node.value)
223 self.traverse(node.target)
224 self.write(" := ")
225 self.traverse(node.value)
226
227 def visit_Import(self, node):
228 self.fill("import ")
229 self.interleave(lambda: self.write(", "), self.traverse, node.names)
230
231 def visit_ImportFrom(self, node):
232 self.fill("from ")
233 self.write("." * node.level)
234 if node.module:
235 self.write(node.module)
236 self.write(" import ")
237 self.interleave(lambda: self.write(", "), self.traverse, node.names)
238
239 def visit_Assign(self, node):
240 self.fill()
241 for target in node.targets:
242 self.traverse(target)
243 self.write(" = ")
244 self.traverse(node.value)
245 if type_comment := self.get_type_comment(node):
246 self.write(type_comment)
247
248 def visit_AugAssign(self, node):
249 self.fill()
250 self.traverse(node.target)
251 self.write(" " + self.binop[node.op.__class__.__name__] + "= ")
252 self.traverse(node.value)
253
254 def visit_AnnAssign(self, node):
255 self.fill()
256 with self.delimit_if("(", ")", not node.simple and isinstance(node.target, ast.Name)):
257 self.traverse(node.target)
258 self.write(": ")
259 self.traverse(node.annotation)
260 if node.value:
261 self.write(" = ")
262 self.traverse(node.value)
263
264 def visit_Return(self, node):
265 self.fill("return")
266 if node.value:
267 self.write(" ")
268 self.traverse(node.value)
269
270 def visit_Pass(self, node):
271 self.fill("pass")
272
273 def visit_Break(self, node):
274 self.fill("break")
275
276 def visit_Continue(self, node):
277 self.fill("continue")
278
279 def visit_Delete(self, node):
280 self.fill("del ")
281 self.interleave(lambda: self.write(", "), self.traverse, node.targets)
282
283 def visit_Assert(self, node):
284 self.fill("assert ")
285 self.traverse(node.test)
286 if node.msg:
287 self.write(", ")
288 self.traverse(node.msg)
289
290 def visit_Global(self, node):
291 self.fill("global ")
292 self.interleave(lambda: self.write(", "), self.write, node.names)
293
294 def visit_Nonlocal(self, node):
295 self.fill("nonlocal ")
296 self.interleave(lambda: self.write(", "), self.write, node.names)
297
298 def visit_Await(self, node):
299 with self.require_parens(_Precedence.AWAIT, node):
300 self.write("await")
301 if node.value:
302 self.write(" ")
303 self.set_precedence(_Precedence.ATOM, node.value)
304 self.traverse(node.value)
305
306 def visit_Yield(self, node):
307 with self.require_parens(_Precedence.YIELD, node):
308 self.write("yield")
309 if node.value:
310 self.write(" ")
311 self.set_precedence(_Precedence.ATOM, node.value)
312 self.traverse(node.value)
313
314 def visit_YieldFrom(self, node):
315 with self.require_parens(_Precedence.YIELD, node):
316 self.write("yield from ")
317 if not node.value:
318 raise ValueError("Node can't be used without a value attribute.")
319 self.set_precedence(_Precedence.ATOM, node.value)
320 self.traverse(node.value)
321
322 def visit_Raise(self, node):
323 self.fill("raise")
324 if not node.exc:
325 if node.cause:
326 raise ValueError("Node can't use cause without an exception.")
327 return
328 self.write(" ")
329 self.traverse(node.exc)
330 if node.cause:
331 self.write(" from ")
332 self.traverse(node.cause)
333
334 def visit_Try(self, node):
335 self.fill("try")
336 with self.block():
337 self.traverse(node.body)
338 for ex in node.handlers:
339 self.traverse(ex)
340 if node.orelse:
341 self.fill("else")
342 with self.block():
343 self.traverse(node.orelse)
344 if node.finalbody:
345 self.fill("finally")
346 with self.block():
347 self.traverse(node.finalbody)
348
349 def visit_ExceptHandler(self, node):
350 self.fill("except")
351 if node.type:
352 self.write(" ")
353 self.traverse(node.type)
354 if node.name:
355 self.write(" as ")
356 self.write(node.name)
357 with self.block():
358 self.traverse(node.body)
359
360 def visit_ClassDef(self, node):
361 self.maybe_newline()
362 for deco in node.decorator_list:
363 self.fill("@")
364 self.traverse(deco)
365 self.fill("class " + node.name)
366 with self.delimit_if("(", ")", condition = node.bases or node.keywords):
367 comma = False
368 for e in node.bases:
369 if comma:
370 self.write(", ")
371 else:
372 comma = True
373 self.traverse(e)
374 for e in node.keywords:
375 if comma:
376 self.write(", ")
377 else:
378 comma = True
379 self.traverse(e)
380
381 with self.block():
382 self._write_docstring_and_traverse_body(node)
383
384 def visit_FunctionDef(self, node):
385 self._function_helper(node, "def")
386
387 def visit_AsyncFunctionDef(self, node):
388 self._function_helper(node, "async def")
389
390 def _function_helper(self, node, fill_suffix):
391 self.maybe_newline()
392 for deco in node.decorator_list:
393 self.fill("@")
394 self.traverse(deco)
395 def_str = fill_suffix + " " + node.name
396 self.fill(def_str)
397 with self.delimit("(", ")"):
398 self.traverse(node.args)
399 if node.returns:
400 self.write(" -> ")
401 self.traverse(node.returns)
402 with self.block(extra=self.get_type_comment(node)):
403 self._write_docstring_and_traverse_body(node)
404
405 def visit_For(self, node):
406 self._for_helper("for ", node)
407
408 def visit_AsyncFor(self, node):
409 self._for_helper("async for ", node)
410
411 def _for_helper(self, fill, node):
412 self.fill(fill)
413 self.traverse(node.target)
414 self.write(" in ")
415 self.traverse(node.iter)
416 with self.block(extra=self.get_type_comment(node)):
417 self.traverse(node.body)
418 if node.orelse:
419 self.fill("else")
420 with self.block():
421 self.traverse(node.orelse)
422
423 def visit_If(self, node):
424 self.fill("if ")
425 self.traverse(node.test)
426 with self.block():
427 self.traverse(node.body)
428 # collapse nested ifs into equivalent elifs.
429 while node.orelse and len(node.orelse) == 1 and isinstance(node.orelse[0], ast.If):
430 node = node.orelse[0]
431 self.fill("elif ")
432 self.traverse(node.test)
433 with self.block():
434 self.traverse(node.body)
435 # final else
436 if node.orelse:
437 self.fill("else")
438 with self.block():
439 self.traverse(node.orelse)
440
441 def visit_While(self, node):
442 self.fill("while ")
443 self.traverse(node.test)
444 with self.block():
445 self.traverse(node.body)
446 if node.orelse:
447 self.fill("else")
448 with self.block():
449 self.traverse(node.orelse)
450
451 def visit_With(self, node):
452 self.fill("with ")
453 self.interleave(lambda: self.write(", "), self.traverse, node.items)
454 with self.block(extra=self.get_type_comment(node)):
455 self.traverse(node.body)
456
457 def visit_AsyncWith(self, node):
458 self.fill("async with ")
459 self.interleave(lambda: self.write(", "), self.traverse, node.items)
460 with self.block(extra=self.get_type_comment(node)):
461 self.traverse(node.body)
462
463 def _str_literal_helper(
464 self, string, *, quote_types=_ALL_QUOTES, escape_special_whitespace=False
465 ):
466 """Helper for writing string literals, minimizing escapes.
467 Returns the tuple (string literal to write, possible quote types).
468 """
469 def escape_char(c):
470 # \n and \t are non-printable, but we only escape them if
471 # escape_special_whitespace is True
472 if not escape_special_whitespace and c in "\n\t":
473 return c
474 # Always escape backslashes and other non-printable characters
475 if c == "\\" or not c.isprintable():
476 return c.encode("unicode_escape").decode("ascii")
477 return c
478
479 escaped_string = "".join(map(escape_char, string))
480 possible_quotes = quote_types
481 if "\n" in escaped_string:
482 possible_quotes = [q for q in possible_quotes if q in _MULTI_QUOTES]
483 possible_quotes = [q for q in possible_quotes if q not in escaped_string]
484 if not possible_quotes:
485 # If there aren't any possible_quotes, fallback to using repr
486 # on the original string. Try to use a quote from quote_types,
487 # e.g., so that we use triple quotes for docstrings.
488 string = repr(string)
489 quote = next((q for q in quote_types if string[0] in q), string[0])
490 return string[1:-1], [quote]
491 if escaped_string:
492 # Sort so that we prefer '''"''' over """\""""
493 possible_quotes.sort(key=lambda q: q[0] == escaped_string[-1])
494 # If we're using triple quotes and we'd need to escape a final
495 # quote, escape it
496 if possible_quotes[0][0] == escaped_string[-1]:
497 assert len(possible_quotes[0]) == 3
498 escaped_string = escaped_string[:-1] + "\\" + escaped_string[-1]
499 return escaped_string, possible_quotes
500
501 def _write_str_avoiding_backslashes(self, string, *, quote_types=_ALL_QUOTES):
502 """Write string literal value with a best effort attempt to avoid backslashes."""
503 string, quote_types = self._str_literal_helper(string, quote_types=quote_types)
504 quote_type = quote_types[0]
505 self.write(f"{quote_type}{string}{quote_type}")
506
507 def visit_JoinedStr(self, node):
508 self.write("f")
509 if self._avoid_backslashes:
510 self._fstring_JoinedStr(node, self.buffer_writer)
511 self._write_str_avoiding_backslashes(self.buffer)
512 return
513
514 # If we don't need to avoid backslashes globally (i.e., we only need
515 # to avoid them inside FormattedValues), it's cosmetically preferred
516 # to use escaped whitespace. That is, it's preferred to use backslashes
517 # for cases like: f"{x}\n". To accomplish this, we keep track of what
518 # in our buffer corresponds to FormattedValues and what corresponds to
519 # Constant parts of the f-string, and allow escapes accordingly.
520 buffer = []
521 for value in node.values:
522 meth = getattr(self, "_fstring_" + type(value).__name__)
523 meth(value, self.buffer_writer)
524 buffer.append((self.buffer, isinstance(value, ast.Constant)))
525 new_buffer = []
526 quote_types = _ALL_QUOTES
527 for value, is_constant in buffer:
528 # Repeatedly narrow down the list of possible quote_types
529 value, quote_types = self._str_literal_helper(
530 value, quote_types=quote_types,
531 escape_special_whitespace=is_constant
532 )
533 new_buffer.append(value)
534 value = "".join(new_buffer)
535 quote_type = quote_types[0]
536 self.write(f"{quote_type}{value}{quote_type}")
537
538 def visit_FormattedValue(self, node):
539 self.write("f")
540 self._fstring_FormattedValue(node, self.buffer_writer)
541 self._write_str_avoiding_backslashes(self.buffer)
542
543 def _fstring_JoinedStr(self, node, write):
544 for value in node.values:
545 meth = getattr(self, "_fstring_" + type(value).__name__)
546 meth(value, write)
547
548 def _fstring_Constant(self, node, write):
549 if not isinstance(node.value, str):
550 raise ValueError("Constants inside JoinedStr should be a string.")
551 value = node.value.replace("{", "{{").replace("}", "}}")
552 write(value)
553
554 def _fstring_FormattedValue(self, node, write):
555 write("{")
556 unparser = type(self)(_avoid_backslashes=True)
557 unparser.set_precedence(_Precedence.TEST.next(), node.value)
558 expr = unparser.visit(node.value)
559 if expr.startswith("{"):
560 write(" ") # Separate pair of opening brackets as "{ {"
561 if "\\" in expr:
562 raise ValueError("Unable to avoid backslash in f-string expression part")
563 write(expr)
564 if node.conversion != -1:
565 conversion = chr(node.conversion)
566 if conversion not in "sra":
567 raise ValueError("Unknown f-string conversion.")
568 write(f"!{conversion}")
569 if node.format_spec:
570 write(":")
571 meth = getattr(self, "_fstring_" + type(node.format_spec).__name__)
572 meth(node.format_spec, write)
573 write("}")
574
575 def visit_Name(self, node):
576 self.write(node.id)
577
578 def _write_docstring(self, node):
579 self.fill()
580 if node.kind == "u":
581 self.write("u")
582 self._write_str_avoiding_backslashes(node.value, quote_types=_MULTI_QUOTES)
583
584 def _write_constant(self, value):
585 if isinstance(value, (float, complex)):
586 # Substitute overflowing decimal literal for AST infinities,
587 # and inf - inf for NaNs.
588 self.write(
589 repr(value)
590 .replace("inf", _INFSTR)
591 .replace("nan", f"({_INFSTR}-{_INFSTR})")
592 )
593 elif self._avoid_backslashes and isinstance(value, str):
594 self._write_str_avoiding_backslashes(value)
595 else:
596 self.write(repr(value))
597
598 def visit_Constant(self, node):
599 value = node.value
600 if isinstance(value, tuple):
601 with self.delimit("(", ")"):
602 self.items_view(self._write_constant, value)
603 elif value is ...:
604 self.write("...")
605 else:
606 if node.kind == "u":
607 self.write("u")
608 self._write_constant(node.value)
609
610 def visit_List(self, node):
611 with self.delimit("[", "]"):
612 self.interleave(lambda: self.write(", "), self.traverse, node.elts)
613
614 def visit_ListComp(self, node):
615 with self.delimit("[", "]"):
616 self.traverse(node.elt)
617 for gen in node.generators:
618 self.traverse(gen)
619
620 def visit_GeneratorExp(self, node):
621 with self.delimit("(", ")"):
622 self.traverse(node.elt)
623 for gen in node.generators:
624 self.traverse(gen)
625
626 def visit_SetComp(self, node):
627 with self.delimit("{", "}"):
628 self.traverse(node.elt)
629 for gen in node.generators:
630 self.traverse(gen)
631
632 def visit_DictComp(self, node):
633 with self.delimit("{", "}"):
634 self.traverse(node.key)
635 self.write(": ")
636 self.traverse(node.value)
637 for gen in node.generators:
638 self.traverse(gen)
639
640 def visit_comprehension(self, node):
641 if node.is_async:
642 self.write(" async for ")
643 else:
644 self.write(" for ")
645 self.set_precedence(_Precedence.TUPLE, node.target)
646 self.traverse(node.target)
647 self.write(" in ")
648 self.set_precedence(_Precedence.TEST.next(), node.iter, *node.ifs)
649 self.traverse(node.iter)
650 for if_clause in node.ifs:
651 self.write(" if ")
652 self.traverse(if_clause)
653
654 def visit_IfExp(self, node):
655 with self.require_parens(_Precedence.TEST, node):
656 self.set_precedence(_Precedence.TEST.next(), node.body, node.test)
657 self.traverse(node.body)
658 self.write(" if ")
659 self.traverse(node.test)
660 self.write(" else ")
661 self.set_precedence(_Precedence.TEST, node.orelse)
662 self.traverse(node.orelse)
663
664 def visit_Set(self, node):
665 if node.elts:
666 with self.delimit("{", "}"):
667 self.interleave(lambda: self.write(", "), self.traverse, node.elts)
668 else:
669 # `{}` would be interpreted as a dictionary literal, and
670 # `set` might be shadowed. Thus:
671 self.write('{*()}')
672
673 def visit_Dict(self, node):
674 def write_key_value_pair(k, v):
675 self.traverse(k)
676 self.write(": ")
677 self.traverse(v)
678
679 def write_item(item):
680 k, v = item
681 if k is None:
682 # for dictionary unpacking operator in dicts {**{'y': 2}}
683 # see PEP 448 for details
684 self.write("**")
685 self.set_precedence(_Precedence.EXPR, v)
686 self.traverse(v)
687 else:
688 write_key_value_pair(k, v)
689
690 with self.delimit("{", "}"):
691 self.interleave(
692 lambda: self.write(", "), write_item, zip(node.keys, node.values)
693 )
694
695 def visit_Tuple(self, node):
696 with self.delimit("(", ")"):
697 self.items_view(self.traverse, node.elts)
698
699 unop = {"Invert": "~", "Not": "not", "UAdd": "+", "USub": "-"}
700 unop_precedence = {
701 "not": _Precedence.NOT,
702 "~": _Precedence.FACTOR,
703 "+": _Precedence.FACTOR,
704 "-": _Precedence.FACTOR,
705 }
706
707 def visit_UnaryOp(self, node):
708 operator = self.unop[node.op.__class__.__name__]
709 operator_precedence = self.unop_precedence[operator]
710 with self.require_parens(operator_precedence, node):
711 self.write(operator)
712 # factor prefixes (+, -, ~) shouldn't be seperated
713 # from the value they belong, (e.g: +1 instead of + 1)
714 if operator_precedence is not _Precedence.FACTOR:
715 self.write(" ")
716 self.set_precedence(operator_precedence, node.operand)
717 self.traverse(node.operand)
718
719 binop = {
720 "Add": "+",
721 "Sub": "-",
722 "Mult": "*",
723 "MatMult": "@",
724 "Div": "/",
725 "Mod": "%",
726 "LShift": "<<",
727 "RShift": ">>",
728 "BitOr": "|",
729 "BitXor": "^",
730 "BitAnd": "&",
731 "FloorDiv": "//",
732 "Pow": "**",
733 }
734
735 binop_precedence = {
736 "+": _Precedence.ARITH,
737 "-": _Precedence.ARITH,
738 "*": _Precedence.TERM,
739 "@": _Precedence.TERM,
740 "/": _Precedence.TERM,
741 "%": _Precedence.TERM,
742 "<<": _Precedence.SHIFT,
743 ">>": _Precedence.SHIFT,
744 "|": _Precedence.BOR,
745 "^": _Precedence.BXOR,
746 "&": _Precedence.BAND,
747 "//": _Precedence.TERM,
748 "**": _Precedence.POWER,
749 }
750
751 binop_rassoc = frozenset(("**",))
752 def visit_BinOp(self, node):
753 operator = self.binop[node.op.__class__.__name__]
754 operator_precedence = self.binop_precedence[operator]
755 with self.require_parens(operator_precedence, node):
756 if operator in self.binop_rassoc:
757 left_precedence = operator_precedence.next()
758 right_precedence = operator_precedence
759 else:
760 left_precedence = operator_precedence
761 right_precedence = operator_precedence.next()
762
763 self.set_precedence(left_precedence, node.left)
764 self.traverse(node.left)
765 self.write(f" {operator} ")
766 self.set_precedence(right_precedence, node.right)
767 self.traverse(node.right)
768
769 cmpops = {
770 "Eq": "==",
771 "NotEq": "!=",
772 "Lt": "<",
773 "LtE": "<=",
774 "Gt": ">",
775 "GtE": ">=",
776 "Is": "is",
777 "IsNot": "is not",
778 "In": "in",
779 "NotIn": "not in",
780 }
781
782 def visit_Compare(self, node):
783 with self.require_parens(_Precedence.CMP, node):
784 self.set_precedence(_Precedence.CMP.next(), node.left, *node.comparators)
785 self.traverse(node.left)
786 for o, e in zip(node.ops, node.comparators):
787 self.write(" " + self.cmpops[o.__class__.__name__] + " ")
788 self.traverse(e)
789
790 boolops = {"And": "and", "Or": "or"}
791 boolop_precedence = {"and": _Precedence.AND, "or": _Precedence.OR}
792
793 def visit_BoolOp(self, node):
794 operator = self.boolops[node.op.__class__.__name__]
795 operator_precedence = self.boolop_precedence[operator]
796
797 def increasing_level_traverse(node):
798 nonlocal operator_precedence
799 operator_precedence = operator_precedence.next()
800 self.set_precedence(operator_precedence, node)
801 self.traverse(node)
802
803 with self.require_parens(operator_precedence, node):
804 s = f" {operator} "
805 self.interleave(lambda: self.write(s), increasing_level_traverse, node.values)
806
807 def visit_Attribute(self, node):
808 self.set_precedence(_Precedence.ATOM, node.value)
809 self.traverse(node.value)
810 # Special case: 3.__abs__() is a syntax error, so if node.value
811 # is an integer literal then we need to either parenthesize
812 # it or add an extra space to get 3 .__abs__().
813 if isinstance(node.value, ast.Constant) and isinstance(node.value.value, int):
814 self.write(" ")
815 self.write(".")
816 self.write(node.attr)
817
818 def visit_Call(self, node):
819 self.set_precedence(_Precedence.ATOM, node.func)
820 self.traverse(node.func)
821 with self.delimit("(", ")"):
822 comma = False
823 for e in node.args:
824 if comma:
825 self.write(", ")
826 else:
827 comma = True
828 self.traverse(e)
829 for e in node.keywords:
830 if comma:
831 self.write(", ")
832 else:
833 comma = True
834 self.traverse(e)
835
836 def visit_Subscript(self, node):
837 def is_simple_tuple(slice_value):
838 # when unparsing a non-empty tuple, the parantheses can be safely
839 # omitted if there aren't any elements that explicitly requires
840 # parantheses (such as starred expressions).
841 return (
842 isinstance(slice_value, ast.Tuple)
843 and slice_value.elts
844 and not any(isinstance(elt, ast.Starred) for elt in slice_value.elts)
845 )
846
847 self.set_precedence(_Precedence.ATOM, node.value)
848 self.traverse(node.value)
849 with self.delimit("[", "]"):
850 if is_simple_tuple(node.slice):
851 self.items_view(self.traverse, node.slice.elts)
852 else:
853 self.traverse(node.slice)
854
855 def visit_Starred(self, node):
856 self.write("*")
857 self.set_precedence(_Precedence.EXPR, node.value)
858 self.traverse(node.value)
859
860 def visit_Ellipsis(self, node):
861 self.write("...")
862
863 def visit_Slice(self, node):
864 if node.lower:
865 self.traverse(node.lower)
866 self.write(":")
867 if node.upper:
868 self.traverse(node.upper)
869 if node.step:
870 self.write(":")
871 self.traverse(node.step)
872
873 def visit_arg(self, node):
874 self.write(node.arg)
875 if node.annotation:
876 self.write(": ")
877 self.traverse(node.annotation)
878
879 def visit_arguments(self, node):
880 first = True
881 # normal arguments
882 all_args = node.posonlyargs + node.args
883 defaults = [None] * (len(all_args) - len(node.defaults)) + node.defaults
884 for index, elements in enumerate(zip(all_args, defaults), 1):
885 a, d = elements
886 if first:
887 first = False
888 else:
889 self.write(", ")
890 self.traverse(a)
891 if d:
892 self.write("=")
893 self.traverse(d)
894 if index == len(node.posonlyargs):
895 self.write(", /")
896
897 # varargs, or bare '*' if no varargs but keyword-only arguments present
898 if node.vararg or node.kwonlyargs:
899 if first:
900 first = False
901 else:
902 self.write(", ")
903 self.write("*")
904 if node.vararg:
905 self.write(node.vararg.arg)
906 if node.vararg.annotation:
907 self.write(": ")
908 self.traverse(node.vararg.annotation)
909
910 # keyword-only arguments
911 if node.kwonlyargs:
912 for a, d in zip(node.kwonlyargs, node.kw_defaults):
913 self.write(", ")
914 self.traverse(a)
915 if d:
916 self.write("=")
917 self.traverse(d)
918
919 # kwargs
920 if node.kwarg:
921 if first:
922 first = False
923 else:
924 self.write(", ")
925 self.write("**" + node.kwarg.arg)
926 if node.kwarg.annotation:
927 self.write(": ")
928 self.traverse(node.kwarg.annotation)
929
930 def visit_keyword(self, node):
931 if node.arg is None:
932 self.write("**")
933 else:
934 self.write(node.arg)
935 self.write("=")
936 self.traverse(node.value)
937
938 def visit_Lambda(self, node):
939 with self.require_parens(_Precedence.TEST, node):
940 self.write("lambda ")
941 self.traverse(node.args)
942 self.write(": ")
943 self.set_precedence(_Precedence.TEST, node.body)
944 self.traverse(node.body)
945
946 def visit_alias(self, node):
947 self.write(node.name)
948 if node.asname:
949 self.write(" as " + node.asname)
950
951 def visit_withitem(self, node):
952 self.traverse(node.context_expr)
953 if node.optional_vars:
954 self.write(" as ")
955 self.traverse(node.optional_vars)
956
957 def unparse(ast_obj):
958 unparser = _Unparser()
959 return unparser.visit(ast_obj)

Mercurial Repository: eric

eric ide

mercurial