From 4d7226832ddf80b3f2f2b291380e809efca060a9 Mon Sep 17 00:00:00 2001 From: Todd Gamblin Date: Mon, 3 Jan 2022 15:05:33 -0800 Subject: unparser: rename `t` to `node` to mirror upstream These refactors have happened in upstream `ast.unparse()` --- lib/spack/spack/util/unparse/unparser.py | 722 ++++++++++++++++--------------- 1 file changed, 363 insertions(+), 359 deletions(-) diff --git a/lib/spack/spack/util/unparse/unparser.py b/lib/spack/spack/util/unparse/unparser.py index 4f83f8cd12..27197bd699 100644 --- a/lib/spack/spack/util/unparse/unparser.py +++ b/lib/spack/spack/util/unparse/unparser.py @@ -181,22 +181,22 @@ class Unparser: else: return nullcontext() - def require_parens(self, precedence, t): + def require_parens(self, precedence, node): """Shortcut to adding precedence related parens""" - return self.delimit_if("(", ")", self.get_precedence(t) > precedence) + return self.delimit_if("(", ")", self.get_precedence(node) > precedence) - def get_precedence(self, t): - return self._precedences.get(t, _Precedence.TEST) + def get_precedence(self, node): + return self._precedences.get(node, _Precedence.TEST) def set_precedence(self, precedence, *nodes): - for t in nodes: - self._precedences[t] = precedence + for node in nodes: + self._precedences[node] = precedence def dispatch(self, tree): "Dispatcher function, dispatching tree type T to method _T." if isinstance(tree, list): - for t in tree: - self.dispatch(t) + for node in tree: + self.dispatch(node) return meth = getattr(self, "visit_" + tree.__class__.__name__) meth(tree) @@ -232,95 +232,95 @@ class Unparser: self.write(" := ") self.dispatch(tree.value) - def visit_Import(self, t): + def visit_Import(self, node): self.fill("import ") - interleave(lambda: self.write(", "), self.dispatch, t.names) + interleave(lambda: self.write(", "), self.dispatch, node.names) - def visit_ImportFrom(self, t): + def visit_ImportFrom(self, node): # A from __future__ import may affect unparsing, so record it. - if t.module and t.module == '__future__': - self.future_imports.extend(n.name for n in t.names) + if node.module and node.module == '__future__': + self.future_imports.extend(n.name for n in node.names) self.fill("from ") - self.write("." * t.level) - if t.module: - self.write(t.module) + self.write("." * node.level) + if node.module: + self.write(node.module) self.write(" import ") - interleave(lambda: self.write(", "), self.dispatch, t.names) + interleave(lambda: self.write(", "), self.dispatch, node.names) - def visit_Assign(self, t): + def visit_Assign(self, node): self.fill() - for target in t.targets: + for target in node.targets: self.dispatch(target) self.write(" = ") - self.dispatch(t.value) + self.dispatch(node.value) - def visit_AugAssign(self, t): + def visit_AugAssign(self, node): self.fill() - self.dispatch(t.target) - self.write(" " + self.binop[t.op.__class__.__name__] + "= ") - self.dispatch(t.value) + self.dispatch(node.target) + self.write(" " + self.binop[node.op.__class__.__name__] + "= ") + self.dispatch(node.value) - def visit_AnnAssign(self, t): + def visit_AnnAssign(self, node): self.fill() with self.delimit_if( - "(", ")", not t.simple and isinstance(t.target, ast.Name)): - self.dispatch(t.target) + "(", ")", not node.simple and isinstance(node.target, ast.Name)): + self.dispatch(node.target) self.write(": ") - self.dispatch(t.annotation) - if t.value: + self.dispatch(node.annotation) + if node.value: self.write(" = ") - self.dispatch(t.value) + self.dispatch(node.value) - def visit_Return(self, t): + def visit_Return(self, node): self.fill("return") - if t.value: + if node.value: self.write(" ") - self.dispatch(t.value) + self.dispatch(node.value) - def visit_Pass(self, t): + def visit_Pass(self, node): self.fill("pass") - def visit_Break(self, t): + def visit_Break(self, node): self.fill("break") - def visit_Continue(self, t): + def visit_Continue(self, node): self.fill("continue") - def visit_Delete(self, t): + def visit_Delete(self, node): self.fill("del ") - interleave(lambda: self.write(", "), self.dispatch, t.targets) + interleave(lambda: self.write(", "), self.dispatch, node.targets) - def visit_Assert(self, t): + def visit_Assert(self, node): self.fill("assert ") - self.dispatch(t.test) - if t.msg: + self.dispatch(node.test) + if node.msg: self.write(", ") - self.dispatch(t.msg) + self.dispatch(node.msg) - def visit_Exec(self, t): + def visit_Exec(self, node): self.fill("exec ") - self.dispatch(t.body) - if t.globals: + self.dispatch(node.body) + if node.globals: self.write(" in ") - self.dispatch(t.globals) - if t.locals: + self.dispatch(node.globals) + if node.locals: self.write(", ") - self.dispatch(t.locals) + self.dispatch(node.locals) - def visit_Print(self, t): + def visit_Print(self, node): # Use print function so that python 2 unparsing is consistent with 3 if self._py_ver_consistent: self.fill("print") with self.delimit("(", ")"): - values = t.values + values = node.values # Can't tell print(foo, bar, baz) and print((foo, bar, baz)) apart in # python 2 and 3, so treat them the same to make hashes consistent. # Single-tuple print are rare and unlikely to affect package hashes, # esp. as they likely print to stdout. if len(values) == 1 and isinstance(values[0], ast.Tuple): - values = t.values[0].elts + values = node.values[0].elts do_comma = False for e in values: @@ -330,277 +330,277 @@ class Unparser: do_comma = True self.dispatch(e) - if not t.nl: + if not node.nl: if do_comma: self.write(", ") else: do_comma = True self.write("end=''") - if t.dest: + if node.dest: if do_comma: self.write(", ") else: do_comma = True self.write("file=") - self.dispatch(t.dest) + self.dispatch(node.dest) else: # unparse Python 2 print statements self.fill("print ") do_comma = False - if t.dest: + if node.dest: self.write(">>") - self.dispatch(t.dest) + self.dispatch(node.dest) do_comma = True - for e in t.values: + for e in node.values: if do_comma: self.write(", ") else: do_comma = True self.dispatch(e) - if not t.nl: + if not node.nl: self.write(",") - def visit_Global(self, t): + def visit_Global(self, node): self.fill("global ") - interleave(lambda: self.write(", "), self.write, t.names) + interleave(lambda: self.write(", "), self.write, node.names) - def visit_Nonlocal(self, t): + def visit_Nonlocal(self, node): self.fill("nonlocal ") - interleave(lambda: self.write(", "), self.write, t.names) + interleave(lambda: self.write(", "), self.write, node.names) - def visit_Await(self, t): - with self.require_parens(_Precedence.AWAIT, t): + def visit_Await(self, node): + with self.require_parens(_Precedence.AWAIT, node): self.write("await") - if t.value: + if node.value: self.write(" ") - self.set_precedence(_Precedence.ATOM, t.value) - self.dispatch(t.value) + self.set_precedence(_Precedence.ATOM, node.value) + self.dispatch(node.value) - def visit_Yield(self, t): - with self.require_parens(_Precedence.YIELD, t): + def visit_Yield(self, node): + with self.require_parens(_Precedence.YIELD, node): self.write("yield") - if t.value: + if node.value: self.write(" ") - self.set_precedence(_Precedence.ATOM, t.value) - self.dispatch(t.value) + self.set_precedence(_Precedence.ATOM, node.value) + self.dispatch(node.value) - def visit_YieldFrom(self, t): - with self.require_parens(_Precedence.YIELD, t): + def visit_YieldFrom(self, node): + with self.require_parens(_Precedence.YIELD, node): self.write("yield from") - if t.value: + if node.value: self.write(" ") - self.set_precedence(_Precedence.ATOM, t.value) - self.dispatch(t.value) + self.set_precedence(_Precedence.ATOM, node.value) + self.dispatch(node.value) - def visit_Raise(self, t): + def visit_Raise(self, node): self.fill("raise") if six.PY3: - if not t.exc: - assert not t.cause + if not node.exc: + assert not node.cause return self.write(" ") - self.dispatch(t.exc) - if t.cause: + self.dispatch(node.exc) + if node.cause: self.write(" from ") - self.dispatch(t.cause) + self.dispatch(node.cause) else: self.write(" ") - if t.type: - self.dispatch(t.type) - if t.inst: + if node.type: + self.dispatch(node.type) + if node.inst: self.write(", ") - self.dispatch(t.inst) - if t.tback: + self.dispatch(node.inst) + if node.tback: self.write(", ") - self.dispatch(t.tback) + self.dispatch(node.tback) - def visit_Try(self, t): + def visit_Try(self, node): self.fill("try") with self.block(): - self.dispatch(t.body) - for ex in t.handlers: + self.dispatch(node.body) + for ex in node.handlers: self.dispatch(ex) - if t.orelse: + if node.orelse: self.fill("else") with self.block(): - self.dispatch(t.orelse) - if t.finalbody: + self.dispatch(node.orelse) + if node.finalbody: self.fill("finally") with self.block(): - self.dispatch(t.finalbody) + self.dispatch(node.finalbody) - def visit_TryExcept(self, t): + def visit_TryExcept(self, node): self.fill("try") with self.block(): - self.dispatch(t.body) + self.dispatch(node.body) - for ex in t.handlers: + for ex in node.handlers: self.dispatch(ex) - if t.orelse: + if node.orelse: self.fill("else") with self.block(): - self.dispatch(t.orelse) + self.dispatch(node.orelse) - def visit_TryFinally(self, t): - if len(t.body) == 1 and isinstance(t.body[0], ast.TryExcept): + def visit_TryFinally(self, node): + if len(node.body) == 1 and isinstance(node.body[0], ast.TryExcept): # try-except-finally - self.dispatch(t.body) + self.dispatch(node.body) else: self.fill("try") with self.block(): - self.dispatch(t.body) + self.dispatch(node.body) self.fill("finally") with self.block(): - self.dispatch(t.finalbody) + self.dispatch(node.finalbody) - def visit_ExceptHandler(self, t): + def visit_ExceptHandler(self, node): self.fill("except") - if t.type: + if node.type: self.write(" ") - self.dispatch(t.type) - if t.name: + self.dispatch(node.type) + if node.name: self.write(" as ") if six.PY3: - self.write(t.name) + self.write(node.name) else: - self.dispatch(t.name) + self.dispatch(node.name) with self.block(): - self.dispatch(t.body) + self.dispatch(node.body) - def visit_ClassDef(self, t): + def visit_ClassDef(self, node): self.write("\n") - for deco in t.decorator_list: + for deco in node.decorator_list: self.fill("@") self.dispatch(deco) - self.fill("class " + t.name) + self.fill("class " + node.name) if six.PY3: - with self.delimit_if("(", ")", condition=t.bases or t.keywords): + with self.delimit_if("(", ")", condition=node.bases or node.keywords): comma = False - for e in t.bases: + for e in node.bases: if comma: self.write(", ") else: comma = True self.dispatch(e) - for e in t.keywords: + for e in node.keywords: if comma: self.write(", ") else: comma = True self.dispatch(e) if sys.version_info[:2] < (3, 5): - if t.starargs: + if node.starargs: if comma: self.write(", ") else: comma = True self.write("*") - self.dispatch(t.starargs) - if t.kwargs: + self.dispatch(node.starargs) + if node.kwargs: if comma: self.write(", ") else: comma = True self.write("**") - self.dispatch(t.kwargs) - elif t.bases: + self.dispatch(node.kwargs) + elif node.bases: with self.delimit("(", ")"): - for a in t.bases[:-1]: + for a in node.bases[:-1]: self.dispatch(a) self.write(", ") - self.dispatch(t.bases[-1]) + self.dispatch(node.bases[-1]) with self.block(): - self.dispatch(t.body) + self.dispatch(node.body) - def visit_FunctionDef(self, t): - self.__FunctionDef_helper(t, "def") + def visit_FunctionDef(self, node): + self.__FunctionDef_helper(node, "def") - def visit_AsyncFunctionDef(self, t): - self.__FunctionDef_helper(t, "async def") + def visit_AsyncFunctionDef(self, node): + self.__FunctionDef_helper(node, "async def") - def __FunctionDef_helper(self, t, fill_suffix): + def __FunctionDef_helper(self, node, fill_suffix): self.write("\n") - for deco in t.decorator_list: + for deco in node.decorator_list: self.fill("@") self.dispatch(deco) - def_str = fill_suffix + " " + t.name + def_str = fill_suffix + " " + node.name self.fill(def_str) with self.delimit("(", ")"): - self.dispatch(t.args) - if getattr(t, "returns", False): + self.dispatch(node.args) + if getattr(node, "returns", False): self.write(" -> ") - self.dispatch(t.returns) + self.dispatch(node.returns) with self.block(): - self.dispatch(t.body) + self.dispatch(node.body) - def visit_For(self, t): - self.__For_helper("for ", t) + def visit_For(self, node): + self.__For_helper("for ", node) - def visit_AsyncFor(self, t): - self.__For_helper("async for ", t) + def visit_AsyncFor(self, node): + self.__For_helper("async for ", node) - def __For_helper(self, fill, t): + def __For_helper(self, fill, node): self.fill(fill) - self.dispatch(t.target) + self.dispatch(node.target) self.write(" in ") - self.dispatch(t.iter) + self.dispatch(node.iter) with self.block(): - self.dispatch(t.body) - if t.orelse: + self.dispatch(node.body) + if node.orelse: self.fill("else") with self.block(): - self.dispatch(t.orelse) + self.dispatch(node.orelse) - def visit_If(self, t): + def visit_If(self, node): self.fill("if ") - self.dispatch(t.test) + self.dispatch(node.test) with self.block(): - self.dispatch(t.body) + self.dispatch(node.body) # collapse nested ifs into equivalent elifs. - while (t.orelse and len(t.orelse) == 1 and - isinstance(t.orelse[0], ast.If)): - t = t.orelse[0] + while (node.orelse and len(node.orelse) == 1 and + isinstance(node.orelse[0], ast.If)): + node = node.orelse[0] self.fill("elif ") - self.dispatch(t.test) + self.dispatch(node.test) with self.block(): - self.dispatch(t.body) + self.dispatch(node.body) # final else - if t.orelse: + if node.orelse: self.fill("else") with self.block(): - self.dispatch(t.orelse) + self.dispatch(node.orelse) - def visit_While(self, t): + def visit_While(self, node): self.fill("while ") - self.dispatch(t.test) + self.dispatch(node.test) with self.block(): - self.dispatch(t.body) - if t.orelse: + self.dispatch(node.body) + if node.orelse: self.fill("else") with self.block(): - self.dispatch(t.orelse) + self.dispatch(node.orelse) - def _generic_With(self, t, async_=False): + def _generic_With(self, node, async_=False): self.fill("async with " if async_ else "with ") - if hasattr(t, 'items'): - interleave(lambda: self.write(", "), self.dispatch, t.items) + if hasattr(node, 'items'): + interleave(lambda: self.write(", "), self.dispatch, node.items) else: - self.dispatch(t.context_expr) - if t.optional_vars: + self.dispatch(node.context_expr) + if node.optional_vars: self.write(" as ") - self.dispatch(t.optional_vars) + self.dispatch(node.optional_vars) with self.block(): - self.dispatch(t.body) + self.dispatch(node.body) - def visit_With(self, t): - self._generic_With(t) + def visit_With(self, node): + self._generic_With(node) - def visit_AsyncWith(self, t): - self._generic_With(t, async_=True) + def visit_AsyncWith(self, node): + self._generic_With(node, async_=True) def _str_literal_helper( self, string, quote_types=_ALL_QUOTES, escape_special_whitespace=False @@ -650,8 +650,8 @@ class Unparser: )) # expr - def visit_Bytes(self, t): - self.write(repr(t.s)) + def visit_Bytes(self, node): + self.write(repr(node.s)) def visit_Str(self, tree): if six.PY3: @@ -675,13 +675,13 @@ class Unparser: else: assert False, "shouldn't get here" - def visit_JoinedStr(self, t): + def visit_JoinedStr(self, node): # JoinedStr(expr* values) self.write("f") if self._avoid_backslashes: string = StringIO() - self._fstring_JoinedStr(t, string.write) + self._fstring_JoinedStr(node, string.write) self._write_str_avoiding_backslashes(string.getvalue()) return @@ -692,7 +692,7 @@ class Unparser: # in our buffer corresponds to FormattedValues and what corresponds to # Constant parts of the f-string, and allow escapes accordingly. buffer = [] - for value in t.values: + for value in node.values: meth = getattr(self, "_fstring_" + type(value).__name__) string = StringIO() meth(value, string.write) @@ -713,30 +713,30 @@ class Unparser: value=value, )) - def visit_FormattedValue(self, t): + def visit_FormattedValue(self, node): # FormattedValue(expr value, int? conversion, expr? format_spec) self.write("f") string = StringIO() - self._fstring_JoinedStr(t, string.write) + self._fstring_JoinedStr(node, string.write) self._write_str_avoiding_backslashes(string.getvalue()) - def _fstring_JoinedStr(self, t, write): - for value in t.values: + def _fstring_JoinedStr(self, node, write): + for value in node.values: print(" ", value) meth = getattr(self, "_fstring_" + type(value).__name__) print(meth) meth(value, write) - def _fstring_Str(self, t, write): - value = t.s.replace("{", "{{").replace("}", "}}") + def _fstring_Str(self, node, write): + value = node.s.replace("{", "{{").replace("}", "}}") write(value) - def _fstring_Constant(self, t, write): - assert isinstance(t.value, str) - value = t.value.replace("{", "{{").replace("}", "}}") + def _fstring_Constant(self, node, write): + assert isinstance(node.value, str) + value = node.value.replace("{", "{{").replace("}", "}}") write(value) - def _fstring_FormattedValue(self, t, write): + def _fstring_FormattedValue(self, node, write): write("{") expr = StringIO() @@ -744,8 +744,8 @@ class Unparser: py_ver_consistent=self._py_ver_consistent, _avoid_backslashes=True, ) - unparser.set_precedence(pnext(_Precedence.TEST), t.value) - unparser.visit(t.value, expr) + unparser.set_precedence(pnext(_Precedence.TEST), node.value) + unparser.visit(node.value, expr) expr = expr.getvalue().rstrip("\n") if expr.startswith("{"): @@ -753,25 +753,25 @@ class Unparser: if "\\" in expr: raise ValueError("Unable to avoid backslash in f-string expression part") write(expr) - if t.conversion != -1: - conversion = chr(t.conversion) + if node.conversion != -1: + conversion = chr(node.conversion) assert conversion in "sra" write("!{conversion}".format(conversion=conversion)) - if t.format_spec: + if node.format_spec: write(":") - meth = getattr(self, "_fstring_" + type(t.format_spec).__name__) - meth(t.format_spec, write) + meth = getattr(self, "_fstring_" + type(node.format_spec).__name__) + meth(node.format_spec, write) write("}") - def visit_Name(self, t): - self.write(t.id) + def visit_Name(self, node): + self.write(node.id) - def visit_NameConstant(self, t): - self.write(repr(t.value)) + def visit_NameConstant(self, node): + self.write(repr(node.value)) - def visit_Repr(self, t): + def visit_Repr(self, node): self.write("`") - self.dispatch(t.value) + self.dispatch(node.value) self.write("`") def _write_constant(self, value): @@ -790,90 +790,90 @@ class Unparser: else: self.write(repr(value)) - def visit_Constant(self, t): - value = t.value + def visit_Constant(self, node): + value = node.value if isinstance(value, tuple): with self.delimit("(", ")"): self.items_view(self._write_constant, value) elif value is Ellipsis: # instead of `...` for Py2 compatibility self.write("...") else: - if t.kind == "u": + if node.kind == "u": self.write("u") - self._write_constant(t.value) + self._write_constant(node.value) - def visit_Num(self, t): - repr_n = repr(t.n) + def visit_Num(self, node): + repr_n = repr(node.n) if six.PY3: self.write(repr_n.replace("inf", INFSTR)) else: # Parenthesize negative numbers, to avoid turning (-1)**2 into -1**2. - with self.require_parens(pnext(_Precedence.FACTOR), t): + with self.require_parens(pnext(_Precedence.FACTOR), node): if "inf" in repr_n and repr_n.endswith("*j"): repr_n = repr_n.replace("*j", "j") # Substitute overflowing decimal literal for AST infinities. self.write(repr_n.replace("inf", INFSTR)) - def visit_List(self, t): + def visit_List(self, node): with self.delimit("[", "]"): - interleave(lambda: self.write(", "), self.dispatch, t.elts) + interleave(lambda: self.write(", "), self.dispatch, node.elts) - def visit_ListComp(self, t): + def visit_ListComp(self, node): with self.delimit("[", "]"): - self.dispatch(t.elt) - for gen in t.generators: + self.dispatch(node.elt) + for gen in node.generators: self.dispatch(gen) - def visit_GeneratorExp(self, t): + def visit_GeneratorExp(self, node): with self.delimit("(", ")"): - self.dispatch(t.elt) - for gen in t.generators: + self.dispatch(node.elt) + for gen in node.generators: self.dispatch(gen) - def visit_SetComp(self, t): + def visit_SetComp(self, node): with self.delimit("{", "}"): - self.dispatch(t.elt) - for gen in t.generators: + self.dispatch(node.elt) + for gen in node.generators: self.dispatch(gen) - def visit_DictComp(self, t): + def visit_DictComp(self, node): with self.delimit("{", "}"): - self.dispatch(t.key) + self.dispatch(node.key) self.write(": ") - self.dispatch(t.value) - for gen in t.generators: + self.dispatch(node.value) + for gen in node.generators: self.dispatch(gen) - def visit_comprehension(self, t): - if getattr(t, 'is_async', False): + def visit_comprehension(self, node): + if getattr(node, 'is_async', False): self.write(" async for ") else: self.write(" for ") - self.set_precedence(_Precedence.TUPLE, t.target) - self.dispatch(t.target) + self.set_precedence(_Precedence.TUPLE, node.target) + self.dispatch(node.target) self.write(" in ") - self.set_precedence(pnext(_Precedence.TEST), t.iter, *t.ifs) - self.dispatch(t.iter) - for if_clause in t.ifs: + self.set_precedence(pnext(_Precedence.TEST), node.iter, *node.ifs) + self.dispatch(node.iter) + for if_clause in node.ifs: self.write(" if ") self.dispatch(if_clause) - def visit_IfExp(self, t): - with self.require_parens(_Precedence.TEST, t): - self.set_precedence(pnext(_Precedence.TEST), t.body, t.test) - self.dispatch(t.body) + def visit_IfExp(self, node): + with self.require_parens(_Precedence.TEST, node): + self.set_precedence(pnext(_Precedence.TEST), node.body, node.test) + self.dispatch(node.body) self.write(" if ") - self.dispatch(t.test) + self.dispatch(node.test) self.write(" else ") - self.set_precedence(_Precedence.TEST, t.orelse) - self.dispatch(t.orelse) + self.set_precedence(_Precedence.TEST, node.orelse) + self.dispatch(node.orelse) - def visit_Set(self, t): - assert(t.elts) # should be at least one element + def visit_Set(self, node): + assert(node.elts) # should be at least one element with self.delimit("{", "}"): - interleave(lambda: self.write(", "), self.dispatch, t.elts) + interleave(lambda: self.write(", "), self.dispatch, node.elts) - def visit_Dict(self, t): + def visit_Dict(self, node): def write_key_value_pair(k, v): self.dispatch(k) self.write(": ") @@ -891,11 +891,15 @@ class Unparser: write_key_value_pair(k, v) with self.delimit("{", "}"): - interleave(lambda: self.write(", "), write_item, zip(t.keys, t.values)) + interleave( + lambda: self.write(", "), + write_item, + zip(node.keys, node.values) + ) - def visit_Tuple(self, t): + def visit_Tuple(self, node): with self.delimit("(", ")"): - self.items_view(self.dispatch, t.elts) + self.items_view(self.dispatch, node.elts) unop = { "Invert": "~", @@ -911,28 +915,28 @@ class Unparser: "-": _Precedence.FACTOR, } - def visit_UnaryOp(self, t): - operator = self.unop[t.op.__class__.__name__] + def visit_UnaryOp(self, node): + operator = self.unop[node.op.__class__.__name__] operator_precedence = self.unop_precedence[operator] - with self.require_parens(operator_precedence, t): + with self.require_parens(operator_precedence, node): self.write(operator) # factor prefixes (+, -, ~) shouldn't be separated # from the value they belong, (e.g: +1 instead of + 1) if operator_precedence != _Precedence.FACTOR: self.write(" ") - self.set_precedence(operator_precedence, t.operand) + self.set_precedence(operator_precedence, node.operand) if (six.PY2 and - isinstance(t.op, ast.USub) and isinstance(t.operand, ast.Num)): + isinstance(node.op, ast.USub) and isinstance(node.operand, ast.Num)): # If we're applying unary minus to a number, parenthesize the number. # This is necessary: -2147483648 is different from -(2147483648) on # a 32-bit machine (the first is an int, the second a long), and # -7j is different from -(7j). (The first has real part 0.0, the second # has real part -0.0.) with self.delimit("(", ")"): - self.dispatch(t.operand) + self.dispatch(node.operand) else: - self.dispatch(t.operand) + self.dispatch(node.operand) binop = { "Add": "+", @@ -968,10 +972,10 @@ class Unparser: binop_rassoc = frozenset(("**",)) - def visit_BinOp(self, t): - operator = self.binop[t.op.__class__.__name__] + def visit_BinOp(self, node): + operator = self.binop[node.op.__class__.__name__] operator_precedence = self.binop_precedence[operator] - with self.require_parens(operator_precedence, t): + with self.require_parens(operator_precedence, node): if operator in self.binop_rassoc: left_precedence = pnext(operator_precedence) right_precedence = operator_precedence @@ -979,11 +983,11 @@ class Unparser: left_precedence = operator_precedence right_precedence = pnext(operator_precedence) - self.set_precedence(left_precedence, t.left) - self.dispatch(t.left) + self.set_precedence(left_precedence, node.left) + self.dispatch(node.left) self.write(" %s " % operator) - self.set_precedence(right_precedence, t.right) - self.dispatch(t.right) + self.set_precedence(right_precedence, node.right) + self.dispatch(node.right) cmpops = { "Eq": "==", @@ -998,11 +1002,11 @@ class Unparser: "NotIn": "not in", } - def visit_Compare(self, t): - with self.require_parens(_Precedence.CMP, t): - self.set_precedence(pnext(_Precedence.CMP), t.left, *t.comparators) - self.dispatch(t.left) - for o, e in zip(t.ops, t.comparators): + def visit_Compare(self, node): + with self.require_parens(_Precedence.CMP, node): + self.set_precedence(pnext(_Precedence.CMP), node.left, *node.comparators) + self.dispatch(node.left) + for o, e in zip(node.ops, node.comparators): self.write(" " + self.cmpops[o.__class__.__name__] + " ") self.dispatch(e) @@ -1016,45 +1020,45 @@ class Unparser: "or": _Precedence.OR, } - def visit_BoolOp(self, t): - operator = self.boolops[t.op.__class__.__name__] + def visit_BoolOp(self, node): + operator = self.boolops[node.op.__class__.__name__] # use a dict instead of nonlocal for Python 2 compatibility op = {"precedence": self.boolop_precedence[operator]} - def increasing_level_dispatch(t): + def increasing_level_dispatch(node): op["precedence"] = pnext(op["precedence"]) - self.set_precedence(op["precedence"], t) - self.dispatch(t) + self.set_precedence(op["precedence"], node) + self.dispatch(node) - with self.require_parens(op["precedence"], t): + with self.require_parens(op["precedence"], node): s = " %s " % operator - interleave(lambda: self.write(s), increasing_level_dispatch, t.values) + interleave(lambda: self.write(s), increasing_level_dispatch, node.values) - def visit_Attribute(self, t): - self.set_precedence(_Precedence.ATOM, t.value) - self.dispatch(t.value) - # Special case: 3.__abs__() is a syntax error, so if t.value + def visit_Attribute(self, node): + self.set_precedence(_Precedence.ATOM, node.value) + self.dispatch(node.value) + # Special case: 3.__abs__() is a syntax error, so if node.value # is an integer literal then we need to either parenthesize # it or add an extra space to get 3 .__abs__(). - if (isinstance(t.value, getattr(ast, 'Constant', getattr(ast, 'Num', None))) and - isinstance(t.value.n, int)): + num_type = getattr(ast, 'Constant', getattr(ast, 'Num', None)) + if isinstance(node.value, num_type) and isinstance(node.value.n, int): self.write(" ") self.write(".") - self.write(t.attr) + self.write(node.attr) - def visit_Call(self, t): - self.set_precedence(_Precedence.ATOM, t.func) + def visit_Call(self, node): + self.set_precedence(_Precedence.ATOM, node.func) - args = t.args + args = node.args if self._py_ver_consistent: # make print(a, b, c) and print((a, b, c)) equivalent, since you can't # tell them apart between Python 2 and 3. See _Print() for more details. - if getattr(t.func, "id", None) == "print": - if len(t.args) == 1 and isinstance(t.args[0], ast.Tuple): - args = t.args[0].elts + if getattr(node.func, "id", None) == "print": + if len(node.args) == 1 and isinstance(node.args[0], ast.Tuple): + args = node.args[0].elts - self.dispatch(t.func) + self.dispatch(node.func) with self.delimit("(", ")"): comma = False @@ -1072,7 +1076,7 @@ class Unparser: comma = True self.dispatch(e) - for e in t.keywords: + for e in node.keywords: # starting from Python 3.5 this denotes a kwargs part of the invocation if e.arg is None and move_stars_last: star_and_kwargs.append(e) @@ -1092,74 +1096,74 @@ class Unparser: self.dispatch(e) if sys.version_info[:2] < (3, 5): - if t.starargs: + if node.starargs: if comma: self.write(", ") else: comma = True self.write("*") - self.dispatch(t.starargs) - if t.kwargs: + self.dispatch(node.starargs) + if node.kwargs: if comma: self.write(", ") else: comma = True self.write("**") - self.dispatch(t.kwargs) + self.dispatch(node.kwargs) - def visit_Subscript(self, t): - self.set_precedence(_Precedence.ATOM, t.value) - self.dispatch(t.value) + def visit_Subscript(self, node): + self.set_precedence(_Precedence.ATOM, node.value) + self.dispatch(node.value) with self.delimit("[", "]"): - if is_simple_tuple(t.slice): - self.items_view(self.dispatch, t.slice.elts) + if is_simple_tuple(node.slice): + self.items_view(self.dispatch, node.slice.elts) else: - self.dispatch(t.slice) + self.dispatch(node.slice) - def visit_Starred(self, t): + def visit_Starred(self, node): self.write("*") - self.set_precedence(_Precedence.EXPR, t.value) - self.dispatch(t.value) + self.set_precedence(_Precedence.EXPR, node.value) + self.dispatch(node.value) # slice - def visit_Ellipsis(self, t): + def visit_Ellipsis(self, node): self.write("...") # used in Python <= 3.8 -- see _Subscript for 3.9+ - def visit_Index(self, t): - if is_simple_tuple(t.value): - self.set_precedence(_Precedence.ATOM, t.value) - self.items_view(self.dispatch, t.value.elts) + def visit_Index(self, node): + if is_simple_tuple(node.value): + self.set_precedence(_Precedence.ATOM, node.value) + self.items_view(self.dispatch, node.value.elts) else: - self.set_precedence(_Precedence.TUPLE, t.value) - self.dispatch(t.value) + self.set_precedence(_Precedence.TUPLE, node.value) + self.dispatch(node.value) - def visit_Slice(self, t): - if t.lower: - self.dispatch(t.lower) + def visit_Slice(self, node): + if node.lower: + self.dispatch(node.lower) self.write(":") - if t.upper: - self.dispatch(t.upper) - if t.step: + if node.upper: + self.dispatch(node.upper) + if node.step: self.write(":") - self.dispatch(t.step) + self.dispatch(node.step) - def visit_ExtSlice(self, t): - interleave(lambda: self.write(', '), self.dispatch, t.dims) + def visit_ExtSlice(self, node): + interleave(lambda: self.write(', '), self.dispatch, node.dims) # argument - def visit_arg(self, t): - self.write(t.arg) - if t.annotation: + def visit_arg(self, node): + self.write(node.arg) + if node.annotation: self.write(": ") - self.dispatch(t.annotation) + self.dispatch(node.annotation) # others - def visit_arguments(self, t): + def visit_arguments(self, node): first = True # normal arguments - all_args = getattr(t, 'posonlyargs', []) + t.args - defaults = [None] * (len(all_args) - len(t.defaults)) + t.defaults + all_args = getattr(node, 'posonlyargs', []) + node.args + defaults = [None] * (len(all_args) - len(node.defaults)) + node.defaults for index, elements in enumerate(zip(all_args, defaults), 1): a, d = elements if first: @@ -1170,31 +1174,31 @@ class Unparser: if d: self.write("=") self.dispatch(d) - if index == len(getattr(t, 'posonlyargs', ())): + if index == len(getattr(node, 'posonlyargs', ())): self.write(", /") # varargs, or bare '*' if no varargs but keyword-only arguments present - if t.vararg or getattr(t, "kwonlyargs", False): + if node.vararg or getattr(node, "kwonlyargs", False): if first: first = False else: self.write(", ") self.write("*") - if t.vararg: - if hasattr(t.vararg, 'arg'): - self.write(t.vararg.arg) - if t.vararg.annotation: + if node.vararg: + if hasattr(node.vararg, 'arg'): + self.write(node.vararg.arg) + if node.vararg.annotation: self.write(": ") - self.dispatch(t.vararg.annotation) + self.dispatch(node.vararg.annotation) else: - self.write(t.vararg) - if getattr(t, 'varargannotation', None): + self.write(node.vararg) + if getattr(node, 'varargannotation', None): self.write(": ") - self.dispatch(t.varargannotation) + self.dispatch(node.varargannotation) # keyword-only arguments - if getattr(t, "kwonlyargs", False): - for a, d in zip(t.kwonlyargs, t.kw_defaults): + if getattr(node, "kwonlyargs", False): + for a, d in zip(node.kwonlyargs, node.kw_defaults): if first: first = False else: @@ -1205,46 +1209,46 @@ class Unparser: self.dispatch(d) # kwargs - if t.kwarg: + if node.kwarg: if first: first = False else: self.write(", ") - if hasattr(t.kwarg, 'arg'): - self.write("**" + t.kwarg.arg) - if t.kwarg.annotation: + if hasattr(node.kwarg, 'arg'): + self.write("**" + node.kwarg.arg) + if node.kwarg.annotation: self.write(": ") - self.dispatch(t.kwarg.annotation) + self.dispatch(node.kwarg.annotation) else: - self.write("**" + t.kwarg) - if getattr(t, 'kwargannotation', None): + self.write("**" + node.kwarg) + if getattr(node, 'kwargannotation', None): self.write(": ") - self.dispatch(t.kwargannotation) + self.dispatch(node.kwargannotation) - def visit_keyword(self, t): - if t.arg is None: + def visit_keyword(self, node): + if node.arg is None: # starting from Python 3.5 this denotes a kwargs part of the invocation self.write("**") else: - self.write(t.arg) + self.write(node.arg) self.write("=") - self.dispatch(t.value) + self.dispatch(node.value) - def visit_Lambda(self, t): - with self.require_parens(_Precedence.TEST, t): + def visit_Lambda(self, node): + with self.require_parens(_Precedence.TEST, node): self.write("lambda ") - self.dispatch(t.args) + self.dispatch(node.args) self.write(": ") - self.set_precedence(_Precedence.TEST, t.body) - self.dispatch(t.body) + self.set_precedence(_Precedence.TEST, node.body) + self.dispatch(node.body) - def visit_alias(self, t): - self.write(t.name) - if t.asname: - self.write(" as " + t.asname) + def visit_alias(self, node): + self.write(node.name) + if node.asname: + self.write(" as " + node.asname) - def visit_withitem(self, t): - self.dispatch(t.context_expr) - if t.optional_vars: + def visit_withitem(self, node): + self.dispatch(node.context_expr) + if node.optional_vars: self.write(" as ") - self.dispatch(t.optional_vars) + self.dispatch(node.optional_vars) -- cgit v1.2.3-70-g09d2