Lines Matching refs:node
65 def _raise_malformed_node(node): argument
67 if lno := getattr(node, 'lineno', None):
70 def _convert_num(node): argument
71 if not isinstance(node, Constant) or type(node.value) not in (int, float, complex):
72 _raise_malformed_node(node)
73 return node.value
74 def _convert_signed_num(node): argument
75 if isinstance(node, UnaryOp) and isinstance(node.op, (UAdd, USub)):
76 operand = _convert_num(node.operand)
77 if isinstance(node.op, UAdd):
81 return _convert_num(node)
82 def _convert(node): argument
83 if isinstance(node, Constant):
84 return node.value
85 elif isinstance(node, Tuple):
86 return tuple(map(_convert, node.elts))
87 elif isinstance(node, List):
88 return list(map(_convert, node.elts))
89 elif isinstance(node, Set):
90 return set(map(_convert, node.elts))
91 elif (isinstance(node, Call) and isinstance(node.func, Name) and
92 node.func.id == 'set' and node.args == node.keywords == []):
94 elif isinstance(node, Dict):
95 if len(node.keys) != len(node.values):
96 _raise_malformed_node(node)
97 return dict(zip(map(_convert, node.keys),
98 map(_convert, node.values)))
99 elif isinstance(node, BinOp) and isinstance(node.op, (Add, Sub)):
100 left = _convert_signed_num(node.left)
101 right = _convert_num(node.right)
103 if isinstance(node.op, Add):
107 return _convert_signed_num(node)
111 def dump(node, annotate_fields=True, include_attributes=False, *, indent=None): argument
123 def _format(node, level=0): argument
131 if isinstance(node, AST):
132 cls = type(node)
136 for name in node._fields:
138 value = getattr(node, name)
151 if include_attributes and node._attributes:
152 for name in node._attributes:
154 value = getattr(node, name)
163 return '%s(%s)' % (node.__class__.__name__, ', '.join(args)), not args
164 return '%s(%s%s)' % (node.__class__.__name__, prefix, sep.join(args)), False
165 elif isinstance(node, list):
166 if not node:
168 return '[%s%s]' % (prefix, sep.join(_format(x, level)[0] for x in node)), False
169 return repr(node), True
171 if not isinstance(node, AST):
172 raise TypeError('expected AST, got %r' % node.__class__.__name__)
175 return _format(node)[0]
195 def fix_missing_locations(node): argument
203 def _fix(node, lineno, col_offset, end_lineno, end_col_offset): argument
204 if 'lineno' in node._attributes:
205 if not hasattr(node, 'lineno'):
206 node.lineno = lineno
208 lineno = node.lineno
209 if 'end_lineno' in node._attributes:
210 if getattr(node, 'end_lineno', None) is None:
211 node.end_lineno = end_lineno
213 end_lineno = node.end_lineno
214 if 'col_offset' in node._attributes:
215 if not hasattr(node, 'col_offset'):
216 node.col_offset = col_offset
218 col_offset = node.col_offset
219 if 'end_col_offset' in node._attributes:
220 if getattr(node, 'end_col_offset', None) is None:
221 node.end_col_offset = end_col_offset
223 end_col_offset = node.end_col_offset
224 for child in iter_child_nodes(node):
226 _fix(node, 1, 0, 1, 0)
227 return node
230 def increment_lineno(node, n=1): argument
236 for child in walk(node):
244 return node
247 def iter_fields(node): argument
252 for field in node._fields:
254 yield field, getattr(node, field)
259 def iter_child_nodes(node): argument
264 for name, field in iter_fields(node):
273 def get_docstring(node, clean=True): argument
282 if not isinstance(node, (AsyncFunctionDef, FunctionDef, ClassDef, Module)):
283 raise TypeError("%r can't have docstrings" % node.__class__.__name__)
284 if not(node.body and isinstance(node.body[0], Expr)):
286 node = node.body[0].value
287 if isinstance(node, Str):
288 text = node.s
289 elif isinstance(node, Constant) and isinstance(node.value, str):
290 text = node.value
335 def get_source_segment(source, node, *, padded=False): argument
345 if node.end_lineno is None or node.end_col_offset is None:
347 lineno = node.lineno - 1
348 end_lineno = node.end_lineno - 1
349 col_offset = node.col_offset
350 end_col_offset = node.end_col_offset
372 def walk(node): argument
379 todo = deque([node])
381 node = todo.popleft()
382 todo.extend(iter_child_nodes(node))
383 yield node
406 def visit(self, node): argument
408 method = 'visit_' + node.__class__.__name__
410 return visitor(node)
412 def generic_visit(self, node): argument
414 for field, value in iter_fields(node):
422 def visit_Constant(self, node): argument
423 value = node.value
440 return visitor(node)
441 return self.generic_visit(node)
480 def generic_visit(self, node): argument
481 for field, old_value in iter_fields(node):
497 delattr(node, field)
499 setattr(node, field, new_node)
500 return node
761 def require_parens(self, precedence, node): argument
763 return self.delimit_if("(", ")", self.get_precedence(node) > precedence)
765 def get_precedence(self, node): argument
766 return self._precedences.get(node, _Precedence.TEST)
769 for node in nodes:
770 self._precedences[node] = precedence
772 def get_raw_docstring(self, node): argument
778 node, (AsyncFunctionDef, FunctionDef, ClassDef, Module)
779 ) or len(node.body) < 1:
781 node = node.body[0]
782 if not isinstance(node, Expr):
784 node = node.value
785 if isinstance(node, Constant) and isinstance(node.value, str):
786 return node
788 def get_type_comment(self, node): argument
789 comment = self._type_ignores.get(node.lineno) or node.type_comment
793 def traverse(self, node): argument
794 if isinstance(node, list):
795 for item in node:
798 super().visit(node)
803 def visit(self, node): argument
807 self.traverse(node)
810 def _write_docstring_and_traverse_body(self, node): argument
811 if (docstring := self.get_raw_docstring(node)):
813 self.traverse(node.body[1:])
815 self.traverse(node.body)
817 def visit_Module(self, node): argument
820 for ignore in node.type_ignores
822 self._write_docstring_and_traverse_body(node)
825 def visit_FunctionType(self, node): argument
828 lambda: self.write(", "), self.traverse, node.argtypes
832 self.traverse(node.returns)
834 def visit_Expr(self, node): argument
836 self.set_precedence(_Precedence.YIELD, node.value)
837 self.traverse(node.value)
839 def visit_NamedExpr(self, node): argument
840 with self.require_parens(_Precedence.TUPLE, node):
841 self.set_precedence(_Precedence.ATOM, node.target, node.value)
842 self.traverse(node.target)
844 self.traverse(node.value)
846 def visit_Import(self, node): argument
848 self.interleave(lambda: self.write(", "), self.traverse, node.names)
850 def visit_ImportFrom(self, node): argument
852 self.write("." * node.level)
853 if node.module:
854 self.write(node.module)
856 self.interleave(lambda: self.write(", "), self.traverse, node.names)
858 def visit_Assign(self, node): argument
860 for target in node.targets:
863 self.traverse(node.value)
864 if type_comment := self.get_type_comment(node):
867 def visit_AugAssign(self, node): argument
869 self.traverse(node.target)
870 self.write(" " + self.binop[node.op.__class__.__name__] + "= ")
871 self.traverse(node.value)
873 def visit_AnnAssign(self, node): argument
875 with self.delimit_if("(", ")", not node.simple and isinstance(node.target, Name)):
876 self.traverse(node.target)
878 self.traverse(node.annotation)
879 if node.value:
881 self.traverse(node.value)
883 def visit_Return(self, node): argument
885 if node.value:
887 self.traverse(node.value)
889 def visit_Pass(self, node): argument
892 def visit_Break(self, node): argument
895 def visit_Continue(self, node): argument
898 def visit_Delete(self, node): argument
900 self.interleave(lambda: self.write(", "), self.traverse, node.targets)
902 def visit_Assert(self, node): argument
904 self.traverse(node.test)
905 if node.msg:
907 self.traverse(node.msg)
909 def visit_Global(self, node): argument
911 self.interleave(lambda: self.write(", "), self.write, node.names)
913 def visit_Nonlocal(self, node): argument
915 self.interleave(lambda: self.write(", "), self.write, node.names)
917 def visit_Await(self, node): argument
918 with self.require_parens(_Precedence.AWAIT, node):
920 if node.value:
922 self.set_precedence(_Precedence.ATOM, node.value)
923 self.traverse(node.value)
925 def visit_Yield(self, node): argument
926 with self.require_parens(_Precedence.YIELD, node):
928 if node.value:
930 self.set_precedence(_Precedence.ATOM, node.value)
931 self.traverse(node.value)
933 def visit_YieldFrom(self, node): argument
934 with self.require_parens(_Precedence.YIELD, node):
936 if not node.value:
938 self.set_precedence(_Precedence.ATOM, node.value)
939 self.traverse(node.value)
941 def visit_Raise(self, node): argument
943 if not node.exc:
944 if node.cause:
948 self.traverse(node.exc)
949 if node.cause:
951 self.traverse(node.cause)
953 def visit_Try(self, node): argument
956 self.traverse(node.body)
957 for ex in node.handlers:
959 if node.orelse:
962 self.traverse(node.orelse)
963 if node.finalbody:
966 self.traverse(node.finalbody)
968 def visit_ExceptHandler(self, node): argument
970 if node.type:
972 self.traverse(node.type)
973 if node.name:
975 self.write(node.name)
977 self.traverse(node.body)
979 def visit_ClassDef(self, node): argument
981 for deco in node.decorator_list:
984 self.fill("class " + node.name)
985 with self.delimit_if("(", ")", condition = node.bases or node.keywords):
987 for e in node.bases:
993 for e in node.keywords:
1001 self._write_docstring_and_traverse_body(node)
1003 def visit_FunctionDef(self, node): argument
1004 self._function_helper(node, "def")
1006 def visit_AsyncFunctionDef(self, node): argument
1007 self._function_helper(node, "async def")
1009 def _function_helper(self, node, fill_suffix): argument
1011 for deco in node.decorator_list:
1014 def_str = fill_suffix + " " + node.name
1017 self.traverse(node.args)
1018 if node.returns:
1020 self.traverse(node.returns)
1021 with self.block(extra=self.get_type_comment(node)):
1022 self._write_docstring_and_traverse_body(node)
1024 def visit_For(self, node): argument
1025 self._for_helper("for ", node)
1027 def visit_AsyncFor(self, node): argument
1028 self._for_helper("async for ", node)
1030 def _for_helper(self, fill, node): argument
1032 self.traverse(node.target)
1034 self.traverse(node.iter)
1035 with self.block(extra=self.get_type_comment(node)):
1036 self.traverse(node.body)
1037 if node.orelse:
1040 self.traverse(node.orelse)
1042 def visit_If(self, node): argument
1044 self.traverse(node.test)
1046 self.traverse(node.body)
1048 while node.orelse and len(node.orelse) == 1 and isinstance(node.orelse[0], If):
1049 node = node.orelse[0]
1051 self.traverse(node.test)
1053 self.traverse(node.body)
1055 if node.orelse:
1058 self.traverse(node.orelse)
1060 def visit_While(self, node): argument
1062 self.traverse(node.test)
1064 self.traverse(node.body)
1065 if node.orelse:
1068 self.traverse(node.orelse)
1070 def visit_With(self, node): argument
1072 self.interleave(lambda: self.write(", "), self.traverse, node.items)
1073 with self.block(extra=self.get_type_comment(node)):
1074 self.traverse(node.body)
1076 def visit_AsyncWith(self, node): argument
1078 self.interleave(lambda: self.write(", "), self.traverse, node.items)
1079 with self.block(extra=self.get_type_comment(node)):
1080 self.traverse(node.body)
1126 def visit_JoinedStr(self, node): argument
1129 self._fstring_JoinedStr(node, self.buffer_writer)
1140 for value in node.values:
1157 def visit_FormattedValue(self, node): argument
1159 self._fstring_FormattedValue(node, self.buffer_writer)
1162 def _fstring_JoinedStr(self, node, write): argument
1163 for value in node.values:
1167 def _fstring_Constant(self, node, write): argument
1168 if not isinstance(node.value, str):
1170 value = node.value.replace("{", "{{").replace("}", "}}")
1173 def _fstring_FormattedValue(self, node, write): argument
1176 unparser.set_precedence(_Precedence.TEST.next(), node.value)
1177 expr = unparser.visit(node.value)
1183 if node.conversion != -1:
1184 conversion = chr(node.conversion)
1188 if node.format_spec:
1190 meth = getattr(self, "_fstring_" + type(node.format_spec).__name__)
1191 meth(node.format_spec, write)
1194 def visit_Name(self, node): argument
1195 self.write(node.id)
1197 def _write_docstring(self, node): argument
1199 if node.kind == "u":
1201 self._write_str_avoiding_backslashes(node.value, quote_types=_MULTI_QUOTES)
1217 def visit_Constant(self, node): argument
1218 value = node.value
1225 if node.kind == "u":
1227 self._write_constant(node.value)
1229 def visit_List(self, node): argument
1231 self.interleave(lambda: self.write(", "), self.traverse, node.elts)
1233 def visit_ListComp(self, node): argument
1235 self.traverse(node.elt)
1236 for gen in node.generators:
1239 def visit_GeneratorExp(self, node): argument
1241 self.traverse(node.elt)
1242 for gen in node.generators:
1245 def visit_SetComp(self, node): argument
1247 self.traverse(node.elt)
1248 for gen in node.generators:
1251 def visit_DictComp(self, node): argument
1253 self.traverse(node.key)
1255 self.traverse(node.value)
1256 for gen in node.generators:
1259 def visit_comprehension(self, node): argument
1260 if node.is_async:
1264 self.set_precedence(_Precedence.TUPLE, node.target)
1265 self.traverse(node.target)
1267 self.set_precedence(_Precedence.TEST.next(), node.iter, *node.ifs)
1268 self.traverse(node.iter)
1269 for if_clause in node.ifs:
1273 def visit_IfExp(self, node): argument
1274 with self.require_parens(_Precedence.TEST, node):
1275 self.set_precedence(_Precedence.TEST.next(), node.body, node.test)
1276 self.traverse(node.body)
1278 self.traverse(node.test)
1280 self.set_precedence(_Precedence.TEST, node.orelse)
1281 self.traverse(node.orelse)
1283 def visit_Set(self, node): argument
1284 if node.elts:
1286 self.interleave(lambda: self.write(", "), self.traverse, node.elts)
1292 def visit_Dict(self, node): argument
1311 lambda: self.write(", "), write_item, zip(node.keys, node.values)
1314 def visit_Tuple(self, node): argument
1316 self.items_view(self.traverse, node.elts)
1326 def visit_UnaryOp(self, node): argument
1327 operator = self.unop[node.op.__class__.__name__]
1329 with self.require_parens(operator_precedence, node):
1335 self.set_precedence(operator_precedence, node.operand)
1336 self.traverse(node.operand)
1371 def visit_BinOp(self, node): argument
1372 operator = self.binop[node.op.__class__.__name__]
1374 with self.require_parens(operator_precedence, node):
1382 self.set_precedence(left_precedence, node.left)
1383 self.traverse(node.left)
1385 self.set_precedence(right_precedence, node.right)
1386 self.traverse(node.right)
1401 def visit_Compare(self, node): argument
1402 with self.require_parens(_Precedence.CMP, node):
1403 self.set_precedence(_Precedence.CMP.next(), node.left, *node.comparators)
1404 self.traverse(node.left)
1405 for o, e in zip(node.ops, node.comparators):
1412 def visit_BoolOp(self, node): argument
1413 operator = self.boolops[node.op.__class__.__name__]
1416 def increasing_level_traverse(node): argument
1419 self.set_precedence(operator_precedence, node)
1420 self.traverse(node)
1422 with self.require_parens(operator_precedence, node):
1424 self.interleave(lambda: self.write(s), increasing_level_traverse, node.values)
1426 def visit_Attribute(self, node): argument
1427 self.set_precedence(_Precedence.ATOM, node.value)
1428 self.traverse(node.value)
1432 if isinstance(node.value, Constant) and isinstance(node.value.value, int):
1435 self.write(node.attr)
1437 def visit_Call(self, node): argument
1438 self.set_precedence(_Precedence.ATOM, node.func)
1439 self.traverse(node.func)
1442 for e in node.args:
1448 for e in node.keywords:
1455 def visit_Subscript(self, node): argument
1466 self.set_precedence(_Precedence.ATOM, node.value)
1467 self.traverse(node.value)
1469 if is_simple_tuple(node.slice):
1470 self.items_view(self.traverse, node.slice.elts)
1472 self.traverse(node.slice)
1474 def visit_Starred(self, node): argument
1476 self.set_precedence(_Precedence.EXPR, node.value)
1477 self.traverse(node.value)
1479 def visit_Ellipsis(self, node): argument
1482 def visit_Slice(self, node): argument
1483 if node.lower:
1484 self.traverse(node.lower)
1486 if node.upper:
1487 self.traverse(node.upper)
1488 if node.step:
1490 self.traverse(node.step)
1492 def visit_Match(self, node): argument
1494 self.traverse(node.subject)
1496 for case in node.cases:
1499 def visit_arg(self, node): argument
1500 self.write(node.arg)
1501 if node.annotation:
1503 self.traverse(node.annotation)
1505 def visit_arguments(self, node): argument
1508 all_args = node.posonlyargs + node.args
1509 defaults = [None] * (len(all_args) - len(node.defaults)) + node.defaults
1520 if index == len(node.posonlyargs):
1524 if node.vararg or node.kwonlyargs:
1530 if node.vararg:
1531 self.write(node.vararg.arg)
1532 if node.vararg.annotation:
1534 self.traverse(node.vararg.annotation)
1537 if node.kwonlyargs:
1538 for a, d in zip(node.kwonlyargs, node.kw_defaults):
1546 if node.kwarg:
1551 self.write("**" + node.kwarg.arg)
1552 if node.kwarg.annotation:
1554 self.traverse(node.kwarg.annotation)
1556 def visit_keyword(self, node): argument
1557 if node.arg is None:
1560 self.write(node.arg)
1562 self.traverse(node.value)
1564 def visit_Lambda(self, node): argument
1565 with self.require_parens(_Precedence.TEST, node):
1567 self.traverse(node.args)
1569 self.set_precedence(_Precedence.TEST, node.body)
1570 self.traverse(node.body)
1572 def visit_alias(self, node): argument
1573 self.write(node.name)
1574 if node.asname:
1575 self.write(" as " + node.asname)
1577 def visit_withitem(self, node): argument
1578 self.traverse(node.context_expr)
1579 if node.optional_vars:
1581 self.traverse(node.optional_vars)
1583 def visit_match_case(self, node): argument
1585 self.traverse(node.pattern)
1586 if node.guard:
1588 self.traverse(node.guard)
1590 self.traverse(node.body)
1592 def visit_MatchValue(self, node): argument
1593 self.traverse(node.value)
1595 def visit_MatchSingleton(self, node): argument
1596 self._write_constant(node.value)
1598 def visit_MatchSequence(self, node): argument
1601 lambda: self.write(", "), self.traverse, node.patterns
1604 def visit_MatchStar(self, node): argument
1605 name = node.name
1610 def visit_MatchMapping(self, node): argument
1618 keys = node.keys
1622 zip(keys, node.patterns, strict=True),
1624 rest = node.rest
1630 def visit_MatchClass(self, node): argument
1631 self.set_precedence(_Precedence.ATOM, node.cls)
1632 self.traverse(node.cls)
1634 patterns = node.patterns
1638 attrs = node.kwd_attrs
1650 zip(attrs, node.kwd_patterns, strict=True),
1653 def visit_MatchAs(self, node): argument
1654 name = node.name
1655 pattern = node.pattern
1659 self.write(node.name)
1661 with self.require_parens(_Precedence.TEST, node):
1662 self.set_precedence(_Precedence.BOR, node.pattern)
1663 self.traverse(node.pattern)
1666 def visit_MatchOr(self, node): argument
1667 with self.require_parens(_Precedence.BOR, node):
1668 self.set_precedence(_Precedence.BOR.next(), *node.patterns)
1669 self.interleave(lambda: self.write(" | "), self.traverse, node.patterns)