Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/astroid/rebuilder.py: 60%
Shortcuts on this page
r m x toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
Shortcuts on this page
r m x toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
1# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
2# For details: https://github.com/pylint-dev/astroid/blob/main/LICENSE
3# Copyright (c) https://github.com/pylint-dev/astroid/blob/main/CONTRIBUTORS.txt
5"""This module contains utilities for rebuilding an _ast tree in
6order to get a single Astroid representation.
7"""
9from __future__ import annotations
11import ast
12import itertools
13import sys
14import token
15from collections.abc import Callable, Collection, Generator
16from io import StringIO
17from tokenize import TokenError, TokenInfo, generate_tokens
18from typing import TYPE_CHECKING, Final, TypeVar, cast, overload
20from astroid import nodes
21from astroid._ast import (
22 BIN_OP_CLASSES,
23 BOOL_OP_CLASSES,
24 CMP_OP_CLASSES,
25 CONTEXT_CLASSES,
26 UNARY_OP_CLASSES,
27 parse_function_type_comment,
28)
29from astroid.const import PY312_PLUS, PY313_PLUS, Context
30from astroid.nodes.utils import Position
31from astroid.typing import InferenceResult
33if TYPE_CHECKING:
34 from astroid.manager import AstroidManager
36 T_Doc = TypeVar(
37 "T_Doc",
38 ast.Module,
39 ast.ClassDef,
40 ast.FunctionDef | ast.AsyncFunctionDef,
41 )
42 _FunctionT = TypeVar("_FunctionT", nodes.FunctionDef, nodes.AsyncFunctionDef)
43 _ForT = TypeVar("_ForT", nodes.For, nodes.AsyncFor)
44 _WithT = TypeVar("_WithT", nodes.With, nodes.AsyncWith)
45 NodesWithDocsType = nodes.Module | nodes.ClassDef | nodes.FunctionDef
48REDIRECT: Final[dict[str, str]] = {
49 "arguments": "Arguments",
50 "comprehension": "Comprehension",
51 "ListCompFor": "Comprehension",
52 "GenExprFor": "Comprehension",
53 "excepthandler": "ExceptHandler",
54 "keyword": "Keyword",
55 "match_case": "MatchCase",
56}
59# noinspection PyMethodMayBeStatic
60class TreeRebuilder:
61 """Rebuilds the _ast tree to become an Astroid tree."""
63 def __init__(
64 self,
65 manager: AstroidManager,
66 data: str | None = None,
67 is_stub: bool = False,
68 ) -> None:
69 self._manager = manager
70 self._data = data.split("\n") if data else None
71 self._is_stub = is_stub
72 self._global_names: list[dict[str, list[nodes.Global]]] = []
73 self._import_from_nodes: list[tuple[nodes.ImportFrom, Collection[str]]] = []
74 self._delayed_assattr: list[nodes.AssignAttr] = []
75 self._visit_meths: dict[
76 type[ast.AST], Callable[[ast.AST, nodes.NodeNG], nodes.NodeNG]
77 ] = {}
79 def _get_doc(self, node: T_Doc) -> tuple[T_Doc, ast.Constant | None]:
80 """Return the doc ast node."""
81 try:
82 if node.body and isinstance(node.body[0], ast.Expr):
83 first_value = node.body[0].value
84 if isinstance(first_value, ast.Constant) and isinstance(
85 first_value.value, str
86 ):
87 doc_ast_node = first_value
88 node.body = node.body[1:]
89 return node, doc_ast_node
90 except IndexError:
91 pass # ast built from scratch
92 return node, None
94 def _get_context(
95 self,
96 node: (
97 ast.Attribute
98 | ast.List
99 | ast.Name
100 | ast.Subscript
101 | ast.Starred
102 | ast.Tuple
103 ),
104 ) -> Context:
105 return CONTEXT_CLASSES.get(type(node.ctx), Context.Load)
107 def _get_position_info(
108 self,
109 node: ast.ClassDef | ast.FunctionDef | ast.AsyncFunctionDef,
110 parent: nodes.ClassDef | nodes.FunctionDef | nodes.AsyncFunctionDef,
111 ) -> Position | None:
112 """Return position information for ClassDef and FunctionDef nodes.
114 In contrast to AST positions, these only include the actual keyword(s)
115 and the class / function name.
117 >>> @decorator
118 >>> async def some_func(var: int) -> None:
119 >>> ^^^^^^^^^^^^^^^^^^^
120 """
121 if not self._data:
122 return None
123 end_lineno = node.end_lineno
124 if node.body:
125 end_lineno = node.body[0].lineno
126 data = "\n".join(self._data[node.lineno - 1 : end_lineno])
128 start_token: TokenInfo | None = None
129 keyword_tokens: tuple[int, ...] = (token.NAME,)
130 if isinstance(parent, nodes.AsyncFunctionDef):
131 search_token = "async"
132 elif isinstance(parent, nodes.FunctionDef):
133 search_token = "def"
134 else:
135 search_token = "class"
137 try:
138 for t in generate_tokens(StringIO(data).readline):
139 if (
140 start_token is not None
141 and t.type == token.NAME
142 and t.string == node.name
143 ):
144 break
145 if t.type in keyword_tokens:
146 if t.string == search_token:
147 start_token = t
148 continue
149 if t.string in {"def"}:
150 continue
151 start_token = None
152 else:
153 return None
154 except (TokenError, SyntaxError):
155 # ``generate_tokens`` can raise on input it cannot tokenize, e.g.
156 # ``TokenError`` for an unterminated bracket on Python < 3.12, or
157 # ``IndentationError`` when ``\r``-terminated lines make the slice
158 # of ``self._data`` (split on ``\n`` only) misaligned with the AST
159 # line numbers; no position info then.
160 return None
162 return Position(
163 lineno=node.lineno + start_token.start[0] - 1,
164 col_offset=start_token.start[1],
165 end_lineno=node.lineno + t.end[0] - 1,
166 end_col_offset=t.end[1],
167 )
169 def visit_module(
170 self, node: ast.Module, modname: str, modpath: str, package: bool
171 ) -> nodes.Module:
172 """Visit a Module node by returning a fresh instance of it.
174 Note: Method not called by 'visit'
175 """
176 node, doc_ast_node = self._get_doc(node)
177 newnode = nodes.Module(
178 name=modname,
179 file=modpath,
180 path=[modpath],
181 package=package,
182 is_stub=self._is_stub,
183 )
184 newnode.postinit(
185 [self.visit(child, newnode) for child in node.body],
186 doc_node=self.visit(doc_ast_node, newnode),
187 )
188 return newnode
190 if TYPE_CHECKING: # noqa: C901
192 @overload
193 def visit(self, node: ast.arg, parent: nodes.NodeNG) -> nodes.AssignName: ...
195 @overload
196 def visit(
197 self, node: ast.arguments, parent: nodes.NodeNG
198 ) -> nodes.Arguments: ...
200 @overload
201 def visit(self, node: ast.Assert, parent: nodes.NodeNG) -> nodes.Assert: ...
203 @overload
204 def visit(
205 self, node: ast.AsyncFunctionDef, parent: nodes.NodeNG
206 ) -> nodes.AsyncFunctionDef: ...
208 @overload
209 def visit(self, node: ast.AsyncFor, parent: nodes.NodeNG) -> nodes.AsyncFor: ...
211 @overload
212 def visit(self, node: ast.Await, parent: nodes.NodeNG) -> nodes.Await: ...
214 @overload
215 def visit(
216 self, node: ast.AsyncWith, parent: nodes.NodeNG
217 ) -> nodes.AsyncWith: ...
219 @overload
220 def visit(self, node: ast.Assign, parent: nodes.NodeNG) -> nodes.Assign: ...
222 @overload
223 def visit(
224 self, node: ast.AnnAssign, parent: nodes.NodeNG
225 ) -> nodes.AnnAssign: ...
227 @overload
228 def visit(
229 self, node: ast.AugAssign, parent: nodes.NodeNG
230 ) -> nodes.AugAssign: ...
232 @overload
233 def visit(self, node: ast.BinOp, parent: nodes.NodeNG) -> nodes.BinOp: ...
235 @overload
236 def visit(self, node: ast.BoolOp, parent: nodes.NodeNG) -> nodes.BoolOp: ...
238 @overload
239 def visit(self, node: ast.Break, parent: nodes.NodeNG) -> nodes.Break: ...
241 @overload
242 def visit(self, node: ast.Call, parent: nodes.NodeNG) -> nodes.Call: ...
244 @overload
245 def visit(self, node: ast.ClassDef, parent: nodes.NodeNG) -> nodes.ClassDef: ...
247 @overload
248 def visit(self, node: ast.Continue, parent: nodes.NodeNG) -> nodes.Continue: ...
250 @overload
251 def visit(self, node: ast.Compare, parent: nodes.NodeNG) -> nodes.Compare: ...
253 @overload
254 def visit(
255 self, node: ast.comprehension, parent: nodes.NodeNG
256 ) -> nodes.Comprehension: ...
258 @overload
259 def visit(self, node: ast.Delete, parent: nodes.NodeNG) -> nodes.Delete: ...
261 @overload
262 def visit(self, node: ast.Dict, parent: nodes.NodeNG) -> nodes.Dict: ...
264 @overload
265 def visit(self, node: ast.DictComp, parent: nodes.NodeNG) -> nodes.DictComp: ...
267 @overload
268 def visit(self, node: ast.Expr, parent: nodes.NodeNG) -> nodes.Expr: ...
270 @overload
271 def visit(
272 self, node: ast.ExceptHandler, parent: nodes.NodeNG
273 ) -> nodes.ExceptHandler: ...
275 @overload
276 def visit(self, node: ast.For, parent: nodes.NodeNG) -> nodes.For: ...
278 @overload
279 def visit(
280 self, node: ast.ImportFrom, parent: nodes.NodeNG
281 ) -> nodes.ImportFrom: ...
283 @overload
284 def visit(
285 self, node: ast.FunctionDef, parent: nodes.NodeNG
286 ) -> nodes.FunctionDef: ...
288 @overload
289 def visit(
290 self, node: ast.GeneratorExp, parent: nodes.NodeNG
291 ) -> nodes.GeneratorExp: ...
293 @overload
294 def visit(
295 self, node: ast.Attribute, parent: nodes.NodeNG
296 ) -> nodes.Attribute: ...
298 @overload
299 def visit(self, node: ast.Global, parent: nodes.NodeNG) -> nodes.Global: ...
301 @overload
302 def visit(self, node: ast.If, parent: nodes.NodeNG) -> nodes.If: ...
304 @overload
305 def visit(self, node: ast.IfExp, parent: nodes.NodeNG) -> nodes.IfExp: ...
307 @overload
308 def visit(self, node: ast.Import, parent: nodes.NodeNG) -> nodes.Import: ...
310 @overload
311 def visit(
312 self, node: ast.JoinedStr, parent: nodes.NodeNG
313 ) -> nodes.JoinedStr: ...
315 @overload
316 def visit(
317 self, node: ast.FormattedValue, parent: nodes.NodeNG
318 ) -> nodes.FormattedValue: ...
320 @overload
321 def visit(
322 self, node: ast.NamedExpr, parent: nodes.NodeNG
323 ) -> nodes.NamedExpr: ...
325 @overload
326 def visit(self, node: ast.keyword, parent: nodes.NodeNG) -> nodes.Keyword: ...
328 @overload
329 def visit(self, node: ast.Lambda, parent: nodes.NodeNG) -> nodes.Lambda: ...
331 @overload
332 def visit(self, node: ast.List, parent: nodes.NodeNG) -> nodes.List: ...
334 @overload
335 def visit(self, node: ast.ListComp, parent: nodes.NodeNG) -> nodes.ListComp: ...
337 @overload
338 def visit(
339 self, node: ast.Name, parent: nodes.NodeNG
340 ) -> nodes.Name | nodes.Const | nodes.AssignName | nodes.DelName: ...
342 @overload
343 def visit(self, node: ast.Nonlocal, parent: nodes.NodeNG) -> nodes.Nonlocal: ...
345 @overload
346 def visit(self, node: ast.Constant, parent: nodes.NodeNG) -> nodes.Const: ...
348 if sys.version_info >= (3, 12):
350 @overload
351 def visit(
352 self, node: ast.ParamSpec, parent: nodes.NodeNG
353 ) -> nodes.ParamSpec: ...
355 @overload
356 def visit(self, node: ast.Pass, parent: nodes.NodeNG) -> nodes.Pass: ...
358 @overload
359 def visit(self, node: ast.Raise, parent: nodes.NodeNG) -> nodes.Raise: ...
361 @overload
362 def visit(self, node: ast.Return, parent: nodes.NodeNG) -> nodes.Return: ...
364 @overload
365 def visit(self, node: ast.Set, parent: nodes.NodeNG) -> nodes.Set: ...
367 @overload
368 def visit(self, node: ast.SetComp, parent: nodes.NodeNG) -> nodes.SetComp: ...
370 @overload
371 def visit(self, node: ast.Slice, parent: nodes.Subscript) -> nodes.Slice: ...
373 @overload
374 def visit(
375 self, node: ast.Subscript, parent: nodes.NodeNG
376 ) -> nodes.Subscript: ...
378 @overload
379 def visit(self, node: ast.Starred, parent: nodes.NodeNG) -> nodes.Starred: ...
381 @overload
382 def visit(self, node: ast.Try, parent: nodes.NodeNG) -> nodes.Try: ...
384 @overload
385 def visit(self, node: ast.TryStar, parent: nodes.NodeNG) -> nodes.TryStar: ...
387 @overload
388 def visit(self, node: ast.Tuple, parent: nodes.NodeNG) -> nodes.Tuple: ...
390 if sys.version_info >= (3, 12):
392 @overload
393 def visit(
394 self, node: ast.TypeAlias, parent: nodes.NodeNG
395 ) -> nodes.TypeAlias: ...
397 @overload
398 def visit(
399 self, node: ast.TypeVar, parent: nodes.NodeNG
400 ) -> nodes.TypeVar: ...
402 @overload
403 def visit(
404 self, node: ast.TypeVarTuple, parent: nodes.NodeNG
405 ) -> nodes.TypeVarTuple: ...
407 @overload
408 def visit(self, node: ast.UnaryOp, parent: nodes.NodeNG) -> nodes.UnaryOp: ...
410 @overload
411 def visit(self, node: ast.While, parent: nodes.NodeNG) -> nodes.While: ...
413 @overload
414 def visit(self, node: ast.With, parent: nodes.NodeNG) -> nodes.With: ...
416 @overload
417 def visit(self, node: ast.Yield, parent: nodes.NodeNG) -> nodes.Yield: ...
419 @overload
420 def visit(
421 self, node: ast.YieldFrom, parent: nodes.NodeNG
422 ) -> nodes.YieldFrom: ...
424 @overload
425 def visit(self, node: ast.Match, parent: nodes.NodeNG) -> nodes.Match: ...
427 @overload
428 def visit(
429 self, node: ast.match_case, parent: nodes.NodeNG
430 ) -> nodes.MatchCase: ...
432 @overload
433 def visit(
434 self, node: ast.MatchValue, parent: nodes.NodeNG
435 ) -> nodes.MatchValue: ...
437 @overload
438 def visit(
439 self, node: ast.MatchSingleton, parent: nodes.NodeNG
440 ) -> nodes.MatchSingleton: ...
442 @overload
443 def visit(
444 self, node: ast.MatchSequence, parent: nodes.NodeNG
445 ) -> nodes.MatchSequence: ...
447 @overload
448 def visit(
449 self, node: ast.MatchMapping, parent: nodes.NodeNG
450 ) -> nodes.MatchMapping: ...
452 @overload
453 def visit(
454 self, node: ast.MatchClass, parent: nodes.NodeNG
455 ) -> nodes.MatchClass: ...
457 @overload
458 def visit(
459 self, node: ast.MatchStar, parent: nodes.NodeNG
460 ) -> nodes.MatchStar: ...
462 @overload
463 def visit(self, node: ast.MatchAs, parent: nodes.NodeNG) -> nodes.MatchAs: ...
465 @overload
466 def visit(self, node: ast.MatchOr, parent: nodes.NodeNG) -> nodes.MatchOr: ...
468 @overload
469 def visit(self, node: ast.pattern, parent: nodes.NodeNG) -> nodes.Pattern: ...
471 if sys.version_info >= (3, 14):
473 @overload
474 def visit(
475 self, node: ast.TemplateStr, parent: nodes.NodeNG
476 ) -> nodes.TemplateStr: ...
478 @overload
479 def visit(
480 self, node: ast.Interpolation, parent: nodes.NodeNG
481 ) -> nodes.Interpolation: ...
483 @overload
484 def visit(self, node: ast.AST, parent: nodes.NodeNG) -> nodes.NodeNG: ...
486 @overload
487 def visit(self, node: None, parent: nodes.NodeNG) -> None: ...
489 def visit(self, node: ast.AST | None, parent: nodes.NodeNG) -> nodes.NodeNG | None:
490 if node is None:
491 return None
492 cls = node.__class__
493 if cls in self._visit_meths:
494 visit_method = self._visit_meths[cls]
495 else:
496 cls_name = cls.__name__
497 visit_name = "visit_" + REDIRECT.get(cls_name, cls_name).lower()
498 visit_method = getattr(self, visit_name)
499 self._visit_meths[cls] = visit_method
500 return visit_method(node, parent)
502 def _save_assignment(self, node: nodes.AssignName | nodes.DelName) -> None:
503 """Save assignment situation since node.parent is not available yet."""
504 if self._global_names and node.name in self._global_names[-1]:
505 node.root().set_local(node.name, node)
506 else:
507 assert node.parent
508 assert node.name
509 node.parent.set_local(node.name, node)
511 def visit_arg(self, node: ast.arg, parent: nodes.NodeNG) -> nodes.AssignName:
512 """Visit an arg node by returning a fresh AssignName instance."""
513 return self.visit_assignname(node, parent, node.arg)
515 def visit_arguments(
516 self, node: ast.arguments, parent: nodes.NodeNG
517 ) -> nodes.Arguments:
518 """Visit an Arguments node by returning a fresh instance of it."""
519 vararg: str | None = None
520 kwarg: str | None = None
521 vararg_node = node.vararg
522 kwarg_node = node.kwarg
524 newnode = nodes.Arguments(
525 node.vararg.arg if node.vararg else None,
526 node.kwarg.arg if node.kwarg else None,
527 parent,
528 (
529 nodes.AssignName(
530 vararg_node.arg,
531 vararg_node.lineno,
532 vararg_node.col_offset,
533 parent,
534 end_lineno=vararg_node.end_lineno,
535 end_col_offset=vararg_node.end_col_offset,
536 )
537 if vararg_node
538 else None
539 ),
540 (
541 nodes.AssignName(
542 kwarg_node.arg,
543 kwarg_node.lineno,
544 kwarg_node.col_offset,
545 parent,
546 end_lineno=kwarg_node.end_lineno,
547 end_col_offset=kwarg_node.end_col_offset,
548 )
549 if kwarg_node
550 else None
551 ),
552 )
553 args = [self.visit(child, newnode) for child in node.args]
554 defaults = [self.visit(child, newnode) for child in node.defaults]
555 varargannotation: nodes.NodeNG | None = None
556 kwargannotation: nodes.NodeNG | None = None
557 if node.vararg:
558 vararg = node.vararg.arg
559 varargannotation = self.visit(node.vararg.annotation, newnode)
560 if node.kwarg:
561 kwarg = node.kwarg.arg
562 kwargannotation = self.visit(node.kwarg.annotation, newnode)
564 kwonlyargs = [self.visit(child, newnode) for child in node.kwonlyargs]
565 kw_defaults = [self.visit(child, newnode) for child in node.kw_defaults]
566 annotations = [self.visit(arg.annotation, newnode) for arg in node.args]
567 kwonlyargs_annotations = [
568 self.visit(arg.annotation, newnode) for arg in node.kwonlyargs
569 ]
571 posonlyargs = [self.visit(child, newnode) for child in node.posonlyargs]
572 posonlyargs_annotations = [
573 self.visit(arg.annotation, newnode) for arg in node.posonlyargs
574 ]
575 type_comment_args = [
576 self.check_type_comment(child, parent=newnode) for child in node.args
577 ]
578 type_comment_kwonlyargs = [
579 self.check_type_comment(child, parent=newnode) for child in node.kwonlyargs
580 ]
581 type_comment_posonlyargs = [
582 self.check_type_comment(child, parent=newnode) for child in node.posonlyargs
583 ]
585 newnode.postinit(
586 args=args,
587 defaults=defaults,
588 kwonlyargs=kwonlyargs,
589 posonlyargs=posonlyargs,
590 kw_defaults=kw_defaults,
591 annotations=annotations,
592 kwonlyargs_annotations=kwonlyargs_annotations,
593 posonlyargs_annotations=posonlyargs_annotations,
594 varargannotation=varargannotation,
595 kwargannotation=kwargannotation,
596 type_comment_args=type_comment_args,
597 type_comment_kwonlyargs=type_comment_kwonlyargs,
598 type_comment_posonlyargs=type_comment_posonlyargs,
599 )
600 if start_end_lineno_pairs := [
601 (arg.lineno, arg.end_lineno)
602 for arg in itertools.chain(
603 node.args, node.posonlyargs, node.kwonlyargs, [node.vararg, node.kwarg]
604 )
605 if arg
606 ]:
607 newnode.lineno = min(startend[0] for startend in start_end_lineno_pairs)
608 newnode.end_lineno = max(startend[1] for startend in start_end_lineno_pairs)
610 # save argument names in locals:
611 assert newnode.parent
612 if vararg:
613 newnode.parent.set_local(vararg, newnode)
614 if kwarg:
615 newnode.parent.set_local(kwarg, newnode)
616 return newnode
618 def visit_assert(self, node: ast.Assert, parent: nodes.NodeNG) -> nodes.Assert:
619 """Visit a Assert node by returning a fresh instance of it."""
620 newnode = nodes.Assert(
621 lineno=node.lineno,
622 col_offset=node.col_offset,
623 end_lineno=node.end_lineno,
624 end_col_offset=node.end_col_offset,
625 parent=parent,
626 )
627 msg: nodes.NodeNG | None = None
628 if node.msg:
629 msg = self.visit(node.msg, newnode)
630 newnode.postinit(self.visit(node.test, newnode), msg)
631 return newnode
633 def check_type_comment(
634 self,
635 node: ast.Assign | ast.arg | ast.For | ast.AsyncFor | ast.With | ast.AsyncWith,
636 parent: (
637 nodes.Assign
638 | nodes.Arguments
639 | nodes.For
640 | nodes.AsyncFor
641 | nodes.With
642 | nodes.AsyncWith
643 ),
644 ) -> nodes.NodeNG | None:
645 if not node.type_comment:
646 return None
648 try:
649 type_comment_ast = ast.parse(node.type_comment, type_comments=True)
650 except (SyntaxError, ValueError, MemoryError, RecursionError):
651 # Invalid type comment, just skip it. ``ast.parse`` may raise
652 # ``MemoryError``/``RecursionError``/``ValueError`` on pathological
653 # inputs (e.g. deeply nested braces produced by fuzzers).
654 return None
656 # For '# type: # any comment' ast.parse returns a Module node,
657 # without any nodes in the body.
658 if not type_comment_ast.body:
659 return None
661 type_object = self.visit(type_comment_ast.body[0], parent=parent)
662 if not isinstance(type_object, nodes.Expr):
663 return None
665 return type_object.value
667 def check_function_type_comment(
668 self, node: ast.FunctionDef | ast.AsyncFunctionDef, parent: nodes.NodeNG
669 ) -> tuple[nodes.NodeNG | None, list[nodes.NodeNG]] | None:
670 if not node.type_comment:
671 return None
673 try:
674 type_comment_ast = parse_function_type_comment(node.type_comment)
675 except (SyntaxError, ValueError, MemoryError, RecursionError):
676 # Invalid type comment, just skip it. ``ast.parse`` may raise
677 # ``MemoryError``/``RecursionError``/``ValueError`` on pathological
678 # inputs (e.g. deeply nested braces produced by fuzzers).
679 return None
681 if not type_comment_ast:
682 return None
684 returns: nodes.NodeNG | None = None
685 argtypes: list[nodes.NodeNG] = [
686 self.visit(elem, parent) for elem in (type_comment_ast.argtypes or [])
687 ]
688 if type_comment_ast.returns:
689 returns = self.visit(type_comment_ast.returns, parent)
691 return returns, argtypes
693 def visit_asyncfunctiondef(
694 self, node: ast.AsyncFunctionDef, parent: nodes.NodeNG
695 ) -> nodes.AsyncFunctionDef:
696 return self._visit_functiondef(nodes.AsyncFunctionDef, node, parent)
698 def visit_asyncfor(
699 self, node: ast.AsyncFor, parent: nodes.NodeNG
700 ) -> nodes.AsyncFor:
701 return self._visit_for(nodes.AsyncFor, node, parent)
703 def visit_await(self, node: ast.Await, parent: nodes.NodeNG) -> nodes.Await:
704 newnode = nodes.Await(
705 lineno=node.lineno,
706 col_offset=node.col_offset,
707 end_lineno=node.end_lineno,
708 end_col_offset=node.end_col_offset,
709 parent=parent,
710 )
711 newnode.postinit(value=self.visit(node.value, newnode))
712 return newnode
714 def visit_asyncwith(
715 self, node: ast.AsyncWith, parent: nodes.NodeNG
716 ) -> nodes.AsyncWith:
717 return self._visit_with(nodes.AsyncWith, node, parent)
719 def visit_assign(self, node: ast.Assign, parent: nodes.NodeNG) -> nodes.Assign:
720 """Visit a Assign node by returning a fresh instance of it."""
721 newnode = nodes.Assign(
722 lineno=node.lineno,
723 col_offset=node.col_offset,
724 end_lineno=node.end_lineno,
725 end_col_offset=node.end_col_offset,
726 parent=parent,
727 )
728 type_annotation = self.check_type_comment(node, parent=newnode)
729 newnode.postinit(
730 targets=[self.visit(child, newnode) for child in node.targets],
731 value=self.visit(node.value, newnode),
732 type_annotation=type_annotation,
733 )
734 return newnode
736 def visit_annassign(
737 self, node: ast.AnnAssign, parent: nodes.NodeNG
738 ) -> nodes.AnnAssign:
739 """Visit an AnnAssign node by returning a fresh instance of it."""
740 newnode = nodes.AnnAssign(
741 lineno=node.lineno,
742 col_offset=node.col_offset,
743 end_lineno=node.end_lineno,
744 end_col_offset=node.end_col_offset,
745 parent=parent,
746 )
747 newnode.postinit(
748 target=self.visit(node.target, newnode),
749 annotation=self.visit(node.annotation, newnode),
750 simple=node.simple,
751 value=self.visit(node.value, newnode),
752 )
753 return newnode
755 @overload
756 def visit_assignname(
757 self, node: ast.AST, parent: nodes.NodeNG, node_name: str
758 ) -> nodes.AssignName: ...
760 @overload
761 def visit_assignname(
762 self, node: ast.AST, parent: nodes.NodeNG, node_name: None
763 ) -> None: ...
765 def visit_assignname(
766 self, node: ast.AST, parent: nodes.NodeNG, node_name: str | None
767 ) -> nodes.AssignName | None:
768 """Visit a node and return a AssignName node.
770 Note: Method not called by 'visit'
771 """
772 if node_name is None:
773 return None
774 newnode = nodes.AssignName(
775 name=node_name,
776 lineno=node.lineno,
777 col_offset=node.col_offset,
778 end_lineno=node.end_lineno,
779 end_col_offset=node.end_col_offset,
780 parent=parent,
781 )
782 self._save_assignment(newnode)
783 return newnode
785 def visit_augassign(
786 self, node: ast.AugAssign, parent: nodes.NodeNG
787 ) -> nodes.AugAssign:
788 """Visit a AugAssign node by returning a fresh instance of it."""
789 newnode = nodes.AugAssign(
790 op=BIN_OP_CLASSES[type(node.op)] + "=",
791 lineno=node.lineno,
792 col_offset=node.col_offset,
793 end_lineno=node.end_lineno,
794 end_col_offset=node.end_col_offset,
795 parent=parent,
796 )
797 newnode.postinit(
798 self.visit(node.target, newnode), self.visit(node.value, newnode)
799 )
800 return newnode
802 def visit_binop(self, node: ast.BinOp, parent: nodes.NodeNG) -> nodes.BinOp:
803 """Visit a BinOp node by returning a fresh instance of it."""
804 newnode = nodes.BinOp(
805 op=BIN_OP_CLASSES[type(node.op)],
806 lineno=node.lineno,
807 col_offset=node.col_offset,
808 end_lineno=node.end_lineno,
809 end_col_offset=node.end_col_offset,
810 parent=parent,
811 )
812 newnode.postinit(
813 self.visit(node.left, newnode), self.visit(node.right, newnode)
814 )
815 return newnode
817 def visit_boolop(self, node: ast.BoolOp, parent: nodes.NodeNG) -> nodes.BoolOp:
818 """Visit a BoolOp node by returning a fresh instance of it."""
819 newnode = nodes.BoolOp(
820 op=BOOL_OP_CLASSES[type(node.op)],
821 lineno=node.lineno,
822 col_offset=node.col_offset,
823 end_lineno=node.end_lineno,
824 end_col_offset=node.end_col_offset,
825 parent=parent,
826 )
827 newnode.postinit([self.visit(child, newnode) for child in node.values])
828 return newnode
830 def visit_break(self, node: ast.Break, parent: nodes.NodeNG) -> nodes.Break:
831 """Visit a Break node by returning a fresh instance of it."""
832 return nodes.Break(
833 lineno=node.lineno,
834 col_offset=node.col_offset,
835 end_lineno=node.end_lineno,
836 end_col_offset=node.end_col_offset,
837 parent=parent,
838 )
840 def visit_call(self, node: ast.Call, parent: nodes.NodeNG) -> nodes.Call:
841 """Visit a CallFunc node by returning a fresh instance of it."""
842 newnode = nodes.Call(
843 lineno=node.lineno,
844 col_offset=node.col_offset,
845 end_lineno=node.end_lineno,
846 end_col_offset=node.end_col_offset,
847 parent=parent,
848 )
849 newnode.postinit(
850 func=self.visit(node.func, newnode),
851 args=[self.visit(child, newnode) for child in node.args],
852 keywords=[self.visit(child, newnode) for child in node.keywords],
853 )
854 return newnode
856 def visit_classdef(
857 self, node: ast.ClassDef, parent: nodes.NodeNG
858 ) -> nodes.ClassDef:
859 """Visit a ClassDef node to become astroid."""
860 node, doc_ast_node = self._get_doc(node)
861 newnode = nodes.ClassDef(
862 name=node.name,
863 lineno=node.lineno,
864 col_offset=node.col_offset,
865 end_lineno=node.end_lineno,
866 end_col_offset=node.end_col_offset,
867 parent=parent,
868 )
869 metaclass = None
870 for keyword in node.keywords:
871 if keyword.arg == "metaclass":
872 metaclass = self.visit(keyword, newnode).value
873 break
874 decorators = self.visit_decorators(node, newnode)
875 newnode.postinit(
876 [self.visit(child, newnode) for child in node.bases],
877 [self.visit(child, newnode) for child in node.body],
878 decorators,
879 metaclass=metaclass,
880 keywords=[
881 self.visit(kwd, newnode)
882 for kwd in node.keywords
883 if kwd.arg != "metaclass"
884 ],
885 position=self._get_position_info(node, newnode),
886 doc_node=self.visit(doc_ast_node, newnode),
887 type_params=(
888 [self.visit(param, newnode) for param in node.type_params]
889 if PY312_PLUS
890 else []
891 ),
892 )
893 parent.set_local(newnode.name, newnode)
894 return newnode
896 def visit_continue(
897 self, node: ast.Continue, parent: nodes.NodeNG
898 ) -> nodes.Continue:
899 """Visit a Continue node by returning a fresh instance of it."""
900 return nodes.Continue(
901 lineno=node.lineno,
902 col_offset=node.col_offset,
903 end_lineno=node.end_lineno,
904 end_col_offset=node.end_col_offset,
905 parent=parent,
906 )
908 def visit_compare(self, node: ast.Compare, parent: nodes.NodeNG) -> nodes.Compare:
909 """Visit a Compare node by returning a fresh instance of it."""
910 newnode = nodes.Compare(
911 lineno=node.lineno,
912 col_offset=node.col_offset,
913 end_lineno=node.end_lineno,
914 end_col_offset=node.end_col_offset,
915 parent=parent,
916 )
917 newnode.postinit(
918 self.visit(node.left, newnode),
919 [
920 (
921 CMP_OP_CLASSES[op.__class__],
922 self.visit(expr, newnode),
923 )
924 for (op, expr) in zip(node.ops, node.comparators)
925 ],
926 )
927 return newnode
929 def visit_comprehension(
930 self, node: ast.comprehension, parent: nodes.NodeNG
931 ) -> nodes.Comprehension:
932 """Visit a Comprehension node by returning a fresh instance of it."""
933 newnode = nodes.Comprehension(
934 parent=parent,
935 # Comprehension nodes don't have these attributes
936 # see https://docs.python.org/3/library/ast.html#abstract-grammar
937 lineno=None,
938 col_offset=None,
939 end_lineno=None,
940 end_col_offset=None,
941 )
942 newnode.postinit(
943 self.visit(node.target, newnode),
944 self.visit(node.iter, newnode),
945 [self.visit(child, newnode) for child in node.ifs],
946 bool(node.is_async),
947 )
948 return newnode
950 def visit_decorators(
951 self,
952 node: ast.ClassDef | ast.FunctionDef | ast.AsyncFunctionDef,
953 parent: nodes.NodeNG,
954 ) -> nodes.Decorators | None:
955 """Visit a Decorators node by returning a fresh instance of it.
957 Note: Method not called by 'visit'
958 """
959 if not node.decorator_list:
960 return None
961 # /!\ node is actually an _ast.FunctionDef node while
962 # parent is an astroid.nodes.FunctionDef node
964 lineno = node.decorator_list[0].lineno
965 end_lineno = node.decorator_list[-1].end_lineno
966 end_col_offset = node.decorator_list[-1].end_col_offset
968 newnode = nodes.Decorators(
969 lineno=lineno,
970 col_offset=node.col_offset,
971 end_lineno=end_lineno,
972 end_col_offset=end_col_offset,
973 parent=parent,
974 )
975 newnode.postinit([self.visit(child, newnode) for child in node.decorator_list])
976 return newnode
978 def visit_delete(self, node: ast.Delete, parent: nodes.NodeNG) -> nodes.Delete:
979 """Visit a Delete node by returning a fresh instance of it."""
980 newnode = nodes.Delete(
981 lineno=node.lineno,
982 col_offset=node.col_offset,
983 end_lineno=node.end_lineno,
984 end_col_offset=node.end_col_offset,
985 parent=parent,
986 )
987 newnode.postinit([self.visit(child, newnode) for child in node.targets])
988 return newnode
990 def _visit_dict_items(
991 self, node: ast.Dict, parent: nodes.NodeNG, newnode: nodes.Dict
992 ) -> Generator[tuple[nodes.NodeNG, nodes.NodeNG]]:
993 for key, value in zip(node.keys, node.values):
994 rebuilt_key: nodes.NodeNG
995 rebuilt_value = self.visit(value, newnode)
996 if not key:
997 # Extended unpacking
998 rebuilt_key = nodes.DictUnpack(
999 lineno=rebuilt_value.lineno,
1000 col_offset=rebuilt_value.col_offset,
1001 end_lineno=rebuilt_value.end_lineno,
1002 end_col_offset=rebuilt_value.end_col_offset,
1003 parent=parent,
1004 )
1005 else:
1006 rebuilt_key = self.visit(key, newnode)
1007 yield rebuilt_key, rebuilt_value
1009 def visit_dict(self, node: ast.Dict, parent: nodes.NodeNG) -> nodes.Dict:
1010 """Visit a Dict node by returning a fresh instance of it."""
1011 newnode = nodes.Dict(
1012 lineno=node.lineno,
1013 col_offset=node.col_offset,
1014 end_lineno=node.end_lineno,
1015 end_col_offset=node.end_col_offset,
1016 parent=parent,
1017 )
1018 items: list[tuple[InferenceResult, InferenceResult]] = list(
1019 self._visit_dict_items(node, parent, newnode)
1020 )
1021 newnode.postinit(items)
1022 return newnode
1024 def visit_dictcomp(
1025 self, node: ast.DictComp, parent: nodes.NodeNG
1026 ) -> nodes.DictComp:
1027 """Visit a DictComp node by returning a fresh instance of it."""
1028 newnode = nodes.DictComp(
1029 lineno=node.lineno,
1030 col_offset=node.col_offset,
1031 end_lineno=node.end_lineno,
1032 end_col_offset=node.end_col_offset,
1033 parent=parent,
1034 )
1035 key: nodes.NodeNG
1036 if node.value is None:
1037 # PEP 798 dict-comprehension unpacking, e.g. ``{**d for d in dicts}``.
1038 # CPython stores the unpacked mapping in ``key`` and leaves
1039 # ``value`` as ``None``. Mirror the ``ast.Dict`` representation of
1040 # ``{**d}``: a ``DictUnpack`` key together with the real value.
1041 value = self.visit(node.key, newnode)
1042 key = nodes.DictUnpack(
1043 lineno=value.lineno,
1044 col_offset=value.col_offset,
1045 end_lineno=value.end_lineno,
1046 end_col_offset=value.end_col_offset,
1047 parent=newnode,
1048 )
1049 else:
1050 key = self.visit(node.key, newnode)
1051 value = self.visit(node.value, newnode)
1052 newnode.postinit(
1053 key,
1054 value,
1055 [self.visit(child, newnode) for child in node.generators],
1056 )
1057 return newnode
1059 def visit_expr(self, node: ast.Expr, parent: nodes.NodeNG) -> nodes.Expr:
1060 """Visit a Expr node by returning a fresh instance of it."""
1061 newnode = nodes.Expr(
1062 lineno=node.lineno,
1063 col_offset=node.col_offset,
1064 end_lineno=node.end_lineno,
1065 end_col_offset=node.end_col_offset,
1066 parent=parent,
1067 )
1068 newnode.postinit(self.visit(node.value, newnode))
1069 return newnode
1071 def visit_excepthandler(
1072 self, node: ast.ExceptHandler, parent: nodes.NodeNG
1073 ) -> nodes.ExceptHandler:
1074 """Visit an ExceptHandler node by returning a fresh instance of it."""
1075 newnode = nodes.ExceptHandler(
1076 lineno=node.lineno,
1077 col_offset=node.col_offset,
1078 end_lineno=node.end_lineno,
1079 end_col_offset=node.end_col_offset,
1080 parent=parent,
1081 )
1082 newnode.postinit(
1083 self.visit(node.type, newnode),
1084 self.visit_assignname(node, newnode, node.name),
1085 [self.visit(child, newnode) for child in node.body],
1086 )
1087 return newnode
1089 @overload
1090 def _visit_for(
1091 self, cls: type[nodes.For], node: ast.For, parent: nodes.NodeNG
1092 ) -> nodes.For: ...
1094 @overload
1095 def _visit_for(
1096 self, cls: type[nodes.AsyncFor], node: ast.AsyncFor, parent: nodes.NodeNG
1097 ) -> nodes.AsyncFor: ...
1099 def _visit_for(
1100 self, cls: type[_ForT], node: ast.For | ast.AsyncFor, parent: nodes.NodeNG
1101 ) -> _ForT:
1102 """Visit a For node by returning a fresh instance of it."""
1103 newnode = cls(
1104 lineno=node.lineno,
1105 col_offset=node.col_offset,
1106 end_lineno=node.end_lineno,
1107 end_col_offset=node.end_col_offset,
1108 parent=parent,
1109 )
1110 type_annotation = self.check_type_comment(node, parent=newnode)
1111 newnode.postinit(
1112 target=self.visit(node.target, newnode),
1113 iter=self.visit(node.iter, newnode),
1114 body=[self.visit(child, newnode) for child in node.body],
1115 orelse=[self.visit(child, newnode) for child in node.orelse],
1116 type_annotation=type_annotation,
1117 )
1118 return newnode
1120 def visit_for(self, node: ast.For, parent: nodes.NodeNG) -> nodes.For:
1121 return self._visit_for(nodes.For, node, parent)
1123 def visit_importfrom(
1124 self, node: ast.ImportFrom, parent: nodes.NodeNG
1125 ) -> nodes.ImportFrom:
1126 """Visit an ImportFrom node by returning a fresh instance of it."""
1127 names = [(alias.name, alias.asname) for alias in node.names]
1128 newnode = nodes.ImportFrom(
1129 fromname=node.module or "",
1130 names=names,
1131 level=node.level or None,
1132 lineno=node.lineno,
1133 col_offset=node.col_offset,
1134 end_lineno=node.end_lineno,
1135 end_col_offset=node.end_col_offset,
1136 parent=parent,
1137 is_lazy=node.is_lazy if sys.version_info >= (3, 15) else 0,
1138 )
1139 # store From names to add them to locals after building
1140 self._import_from_nodes.append(
1141 (newnode, self._global_names[-1].keys() if self._global_names else ())
1142 )
1143 return newnode
1145 @overload
1146 def _visit_functiondef(
1147 self, cls: type[nodes.FunctionDef], node: ast.FunctionDef, parent: nodes.NodeNG
1148 ) -> nodes.FunctionDef: ...
1150 @overload
1151 def _visit_functiondef(
1152 self,
1153 cls: type[nodes.AsyncFunctionDef],
1154 node: ast.AsyncFunctionDef,
1155 parent: nodes.NodeNG,
1156 ) -> nodes.AsyncFunctionDef: ...
1158 def _visit_functiondef(
1159 self,
1160 cls: type[_FunctionT],
1161 node: ast.FunctionDef | ast.AsyncFunctionDef,
1162 parent: nodes.NodeNG,
1163 ) -> _FunctionT:
1164 """Visit an FunctionDef node to become astroid."""
1165 self._global_names.append({})
1166 node, doc_ast_node = self._get_doc(node)
1168 lineno = node.lineno
1169 if node.decorator_list:
1170 # The ast parser of python < 3.8 incorrectly set the line number of
1171 # a decorated function to the line of its first decorator.
1172 # We reset the function's line number to that of the
1173 # first decorator to maintain backward compatibility.
1174 # It's not ideal but this discrepancy was baked into
1175 # the framework for *years*.
1176 lineno = node.decorator_list[0].lineno
1178 newnode = cls(
1179 name=node.name,
1180 lineno=lineno,
1181 col_offset=node.col_offset,
1182 end_lineno=node.end_lineno,
1183 end_col_offset=node.end_col_offset,
1184 parent=parent,
1185 )
1186 decorators = self.visit_decorators(node, newnode)
1187 returns: nodes.NodeNG | None
1188 if node.returns:
1189 returns = self.visit(node.returns, newnode)
1190 else:
1191 returns = None
1193 type_comment_args = type_comment_returns = None
1194 type_comment_annotation = self.check_function_type_comment(node, newnode)
1195 if type_comment_annotation:
1196 type_comment_returns, type_comment_args = type_comment_annotation
1197 newnode.postinit(
1198 args=self.visit(node.args, newnode),
1199 body=[self.visit(child, newnode) for child in node.body],
1200 decorators=decorators,
1201 returns=returns,
1202 type_comment_returns=type_comment_returns,
1203 type_comment_args=type_comment_args,
1204 position=self._get_position_info(node, newnode),
1205 doc_node=self.visit(doc_ast_node, newnode),
1206 type_params=(
1207 [self.visit(param, newnode) for param in node.type_params]
1208 if PY312_PLUS
1209 else []
1210 ),
1211 )
1212 self._global_names.pop()
1213 parent.set_local(newnode.name, newnode)
1214 return newnode
1216 def visit_functiondef(
1217 self, node: ast.FunctionDef, parent: nodes.NodeNG
1218 ) -> nodes.FunctionDef:
1219 return self._visit_functiondef(nodes.FunctionDef, node, parent)
1221 def visit_generatorexp(
1222 self, node: ast.GeneratorExp, parent: nodes.NodeNG
1223 ) -> nodes.GeneratorExp:
1224 """Visit a GeneratorExp node by returning a fresh instance of it."""
1225 newnode = nodes.GeneratorExp(
1226 lineno=node.lineno,
1227 col_offset=node.col_offset,
1228 end_lineno=node.end_lineno,
1229 end_col_offset=node.end_col_offset,
1230 parent=parent,
1231 )
1232 newnode.postinit(
1233 self.visit(node.elt, newnode),
1234 [self.visit(child, newnode) for child in node.generators],
1235 )
1236 return newnode
1238 def visit_attribute(
1239 self, node: ast.Attribute, parent: nodes.NodeNG
1240 ) -> nodes.Attribute | nodes.AssignAttr | nodes.DelAttr:
1241 """Visit an Attribute node by returning a fresh instance of it."""
1242 context = self._get_context(node)
1243 newnode: nodes.Attribute | nodes.AssignAttr | nodes.DelAttr
1244 if context == Context.Del:
1245 # FIXME : maybe we should reintroduce and visit_delattr ?
1246 # for instance, deactivating assign_ctx
1247 newnode = nodes.DelAttr(
1248 attrname=node.attr,
1249 lineno=node.lineno,
1250 col_offset=node.col_offset,
1251 end_lineno=node.end_lineno,
1252 end_col_offset=node.end_col_offset,
1253 parent=parent,
1254 )
1255 elif context == Context.Store:
1256 newnode = nodes.AssignAttr(
1257 attrname=node.attr,
1258 lineno=node.lineno,
1259 col_offset=node.col_offset,
1260 end_lineno=node.end_lineno,
1261 end_col_offset=node.end_col_offset,
1262 parent=parent,
1263 )
1264 # Prohibit a local save if we are in an ExceptHandler.
1265 if not isinstance(parent, nodes.ExceptHandler):
1266 # mypy doesn't recognize that newnode has to be AssignAttr because it
1267 # doesn't support ParamSpec
1268 # See https://github.com/python/mypy/issues/8645
1269 self._delayed_assattr.append(newnode) # type: ignore[arg-type]
1270 else:
1271 newnode = nodes.Attribute(
1272 attrname=node.attr,
1273 lineno=node.lineno,
1274 col_offset=node.col_offset,
1275 end_lineno=node.end_lineno,
1276 end_col_offset=node.end_col_offset,
1277 parent=parent,
1278 )
1279 newnode.postinit(self.visit(node.value, newnode))
1280 return newnode
1282 def visit_global(self, node: ast.Global, parent: nodes.NodeNG) -> nodes.Global:
1283 """Visit a Global node to become astroid."""
1284 newnode = nodes.Global(
1285 names=node.names,
1286 lineno=node.lineno,
1287 col_offset=node.col_offset,
1288 end_lineno=node.end_lineno,
1289 end_col_offset=node.end_col_offset,
1290 parent=parent,
1291 )
1292 if self._global_names: # global at the module level, no effect
1293 for name in node.names:
1294 self._global_names[-1].setdefault(name, []).append(newnode)
1295 return newnode
1297 def visit_if(self, node: ast.If, parent: nodes.NodeNG) -> nodes.If:
1298 """Visit an If node by returning a fresh instance of it."""
1299 newnode = nodes.If(
1300 lineno=node.lineno,
1301 col_offset=node.col_offset,
1302 end_lineno=node.end_lineno,
1303 end_col_offset=node.end_col_offset,
1304 parent=parent,
1305 )
1306 newnode.postinit(
1307 self.visit(node.test, newnode),
1308 [self.visit(child, newnode) for child in node.body],
1309 [self.visit(child, newnode) for child in node.orelse],
1310 )
1311 return newnode
1313 def visit_ifexp(self, node: ast.IfExp, parent: nodes.NodeNG) -> nodes.IfExp:
1314 """Visit a IfExp node by returning a fresh instance of it."""
1315 newnode = nodes.IfExp(
1316 lineno=node.lineno,
1317 col_offset=node.col_offset,
1318 end_lineno=node.end_lineno,
1319 end_col_offset=node.end_col_offset,
1320 parent=parent,
1321 )
1322 newnode.postinit(
1323 self.visit(node.test, newnode),
1324 self.visit(node.body, newnode),
1325 self.visit(node.orelse, newnode),
1326 )
1327 return newnode
1329 def visit_import(self, node: ast.Import, parent: nodes.NodeNG) -> nodes.Import:
1330 """Visit a Import node by returning a fresh instance of it."""
1331 names = [(alias.name, alias.asname) for alias in node.names]
1332 newnode = nodes.Import(
1333 names=names,
1334 lineno=node.lineno,
1335 col_offset=node.col_offset,
1336 end_lineno=node.end_lineno,
1337 end_col_offset=node.end_col_offset,
1338 parent=parent,
1339 is_lazy=node.is_lazy if sys.version_info >= (3, 15) else 0,
1340 )
1341 # save import names in parent's locals:
1342 for name, asname in newnode.names:
1343 name = (asname or name).split(".")[0]
1344 if self._global_names and name in self._global_names[-1]:
1345 parent.root().set_local(name, newnode)
1346 else:
1347 parent.set_local(name, newnode)
1348 return newnode
1350 def visit_joinedstr(
1351 self, node: ast.JoinedStr, parent: nodes.NodeNG
1352 ) -> nodes.JoinedStr:
1353 newnode = nodes.JoinedStr(
1354 lineno=node.lineno,
1355 col_offset=node.col_offset,
1356 end_lineno=node.end_lineno,
1357 end_col_offset=node.end_col_offset,
1358 parent=parent,
1359 )
1360 newnode.postinit([self.visit(child, newnode) for child in node.values])
1361 return newnode
1363 def visit_formattedvalue(
1364 self, node: ast.FormattedValue, parent: nodes.NodeNG
1365 ) -> nodes.FormattedValue:
1366 newnode = nodes.FormattedValue(
1367 lineno=node.lineno,
1368 col_offset=node.col_offset,
1369 end_lineno=node.end_lineno,
1370 end_col_offset=node.end_col_offset,
1371 parent=parent,
1372 )
1373 newnode.postinit(
1374 value=self.visit(node.value, newnode),
1375 conversion=node.conversion,
1376 format_spec=self.visit(node.format_spec, newnode),
1377 )
1378 return newnode
1380 def visit_namedexpr(
1381 self, node: ast.NamedExpr, parent: nodes.NodeNG
1382 ) -> nodes.NamedExpr:
1383 newnode = nodes.NamedExpr(
1384 lineno=node.lineno,
1385 col_offset=node.col_offset,
1386 end_lineno=node.end_lineno,
1387 end_col_offset=node.end_col_offset,
1388 parent=parent,
1389 )
1390 newnode.postinit(
1391 self.visit(node.target, newnode), self.visit(node.value, newnode)
1392 )
1393 return newnode
1395 def visit_keyword(self, node: ast.keyword, parent: nodes.NodeNG) -> nodes.Keyword:
1396 """Visit a Keyword node by returning a fresh instance of it."""
1397 newnode = nodes.Keyword(
1398 arg=node.arg,
1399 lineno=node.lineno,
1400 col_offset=node.col_offset,
1401 end_lineno=node.end_lineno,
1402 end_col_offset=node.end_col_offset,
1403 parent=parent,
1404 )
1405 newnode.postinit(self.visit(node.value, newnode))
1406 return newnode
1408 def visit_lambda(self, node: ast.Lambda, parent: nodes.NodeNG) -> nodes.Lambda:
1409 """Visit a Lambda node by returning a fresh instance of it."""
1410 newnode = nodes.Lambda(
1411 lineno=node.lineno,
1412 col_offset=node.col_offset,
1413 end_lineno=node.end_lineno,
1414 end_col_offset=node.end_col_offset,
1415 parent=parent,
1416 )
1417 newnode.postinit(self.visit(node.args, newnode), self.visit(node.body, newnode))
1418 return newnode
1420 def visit_list(self, node: ast.List, parent: nodes.NodeNG) -> nodes.List:
1421 """Visit a List node by returning a fresh instance of it."""
1422 context = self._get_context(node)
1423 newnode = nodes.List(
1424 ctx=context,
1425 lineno=node.lineno,
1426 col_offset=node.col_offset,
1427 end_lineno=node.end_lineno,
1428 end_col_offset=node.end_col_offset,
1429 parent=parent,
1430 )
1431 newnode.postinit([self.visit(child, newnode) for child in node.elts])
1432 return newnode
1434 def visit_listcomp(
1435 self, node: ast.ListComp, parent: nodes.NodeNG
1436 ) -> nodes.ListComp:
1437 """Visit a ListComp node by returning a fresh instance of it."""
1438 newnode = nodes.ListComp(
1439 lineno=node.lineno,
1440 col_offset=node.col_offset,
1441 end_lineno=node.end_lineno,
1442 end_col_offset=node.end_col_offset,
1443 parent=parent,
1444 )
1445 newnode.postinit(
1446 self.visit(node.elt, newnode),
1447 [self.visit(child, newnode) for child in node.generators],
1448 )
1449 return newnode
1451 def visit_name(
1452 self, node: ast.Name, parent: nodes.NodeNG
1453 ) -> nodes.Name | nodes.AssignName | nodes.DelName:
1454 """Visit a Name node by returning a fresh instance of it."""
1455 context = self._get_context(node)
1456 newnode: nodes.Name | nodes.AssignName | nodes.DelName
1457 if context == Context.Del:
1458 newnode = nodes.DelName(
1459 name=node.id,
1460 lineno=node.lineno,
1461 col_offset=node.col_offset,
1462 end_lineno=node.end_lineno,
1463 end_col_offset=node.end_col_offset,
1464 parent=parent,
1465 )
1466 elif context == Context.Store:
1467 newnode = nodes.AssignName(
1468 name=node.id,
1469 lineno=node.lineno,
1470 col_offset=node.col_offset,
1471 end_lineno=node.end_lineno,
1472 end_col_offset=node.end_col_offset,
1473 parent=parent,
1474 )
1475 else:
1476 newnode = nodes.Name(
1477 name=node.id,
1478 lineno=node.lineno,
1479 col_offset=node.col_offset,
1480 end_lineno=node.end_lineno,
1481 end_col_offset=node.end_col_offset,
1482 parent=parent,
1483 )
1484 # XXX REMOVE me :
1485 if context in (Context.Del, Context.Store): # 'Aug' ??
1486 newnode = cast((nodes.AssignName | nodes.DelName), newnode)
1487 self._save_assignment(newnode)
1488 return newnode
1490 def visit_nonlocal(
1491 self, node: ast.Nonlocal, parent: nodes.NodeNG
1492 ) -> nodes.Nonlocal:
1493 """Visit a Nonlocal node and return a new instance of it."""
1494 return nodes.Nonlocal(
1495 names=node.names,
1496 lineno=node.lineno,
1497 col_offset=node.col_offset,
1498 end_lineno=node.end_lineno,
1499 end_col_offset=node.end_col_offset,
1500 parent=parent,
1501 )
1503 def visit_constant(self, node: ast.Constant, parent: nodes.NodeNG) -> nodes.Const:
1504 """Visit a Constant node by returning a fresh instance of Const."""
1505 return nodes.Const(
1506 value=node.value,
1507 kind=node.kind,
1508 lineno=node.lineno,
1509 col_offset=node.col_offset,
1510 end_lineno=node.end_lineno,
1511 end_col_offset=node.end_col_offset,
1512 parent=parent,
1513 )
1515 def visit_paramspec(
1516 self, node: ast.ParamSpec, parent: nodes.NodeNG
1517 ) -> nodes.ParamSpec:
1518 """Visit a ParamSpec node by returning a fresh instance of it."""
1519 newnode = nodes.ParamSpec(
1520 lineno=node.lineno,
1521 col_offset=node.col_offset,
1522 end_lineno=node.end_lineno,
1523 end_col_offset=node.end_col_offset,
1524 parent=parent,
1525 )
1526 # Add AssignName node for 'node.name'
1527 # https://bugs.python.org/issue43994
1528 newnode.postinit(
1529 name=self.visit_assignname(node, newnode, node.name),
1530 default_value=(
1531 self.visit(node.default_value, newnode) if PY313_PLUS else None
1532 ),
1533 )
1534 return newnode
1536 def visit_pass(self, node: ast.Pass, parent: nodes.NodeNG) -> nodes.Pass:
1537 """Visit a Pass node by returning a fresh instance of it."""
1538 return nodes.Pass(
1539 lineno=node.lineno,
1540 col_offset=node.col_offset,
1541 end_lineno=node.end_lineno,
1542 end_col_offset=node.end_col_offset,
1543 parent=parent,
1544 )
1546 def visit_raise(self, node: ast.Raise, parent: nodes.NodeNG) -> nodes.Raise:
1547 """Visit a Raise node by returning a fresh instance of it."""
1548 newnode = nodes.Raise(
1549 lineno=node.lineno,
1550 col_offset=node.col_offset,
1551 end_lineno=node.end_lineno,
1552 end_col_offset=node.end_col_offset,
1553 parent=parent,
1554 )
1555 # no traceback; anyway it is not used in Pylint
1556 newnode.postinit(
1557 exc=self.visit(node.exc, newnode),
1558 cause=self.visit(node.cause, newnode),
1559 )
1560 return newnode
1562 def visit_return(self, node: ast.Return, parent: nodes.NodeNG) -> nodes.Return:
1563 """Visit a Return node by returning a fresh instance of it."""
1564 newnode = nodes.Return(
1565 lineno=node.lineno,
1566 col_offset=node.col_offset,
1567 end_lineno=node.end_lineno,
1568 end_col_offset=node.end_col_offset,
1569 parent=parent,
1570 )
1571 newnode.postinit(self.visit(node.value, newnode))
1572 return newnode
1574 def visit_set(self, node: ast.Set, parent: nodes.NodeNG) -> nodes.Set:
1575 """Visit a Set node by returning a fresh instance of it."""
1576 newnode = nodes.Set(
1577 lineno=node.lineno,
1578 col_offset=node.col_offset,
1579 end_lineno=node.end_lineno,
1580 end_col_offset=node.end_col_offset,
1581 parent=parent,
1582 )
1583 newnode.postinit([self.visit(child, newnode) for child in node.elts])
1584 return newnode
1586 def visit_setcomp(self, node: ast.SetComp, parent: nodes.NodeNG) -> nodes.SetComp:
1587 """Visit a SetComp node by returning a fresh instance of it."""
1588 newnode = nodes.SetComp(
1589 lineno=node.lineno,
1590 col_offset=node.col_offset,
1591 end_lineno=node.end_lineno,
1592 end_col_offset=node.end_col_offset,
1593 parent=parent,
1594 )
1595 newnode.postinit(
1596 self.visit(node.elt, newnode),
1597 [self.visit(child, newnode) for child in node.generators],
1598 )
1599 return newnode
1601 def visit_slice(self, node: ast.Slice, parent: nodes.Subscript) -> nodes.Slice:
1602 """Visit a Slice node by returning a fresh instance of it."""
1603 newnode = nodes.Slice(
1604 lineno=node.lineno,
1605 col_offset=node.col_offset,
1606 end_lineno=node.end_lineno,
1607 end_col_offset=node.end_col_offset,
1608 parent=parent,
1609 )
1610 newnode.postinit(
1611 lower=self.visit(node.lower, newnode),
1612 upper=self.visit(node.upper, newnode),
1613 step=self.visit(node.step, newnode),
1614 )
1615 return newnode
1617 def visit_subscript(
1618 self, node: ast.Subscript, parent: nodes.NodeNG
1619 ) -> nodes.Subscript:
1620 """Visit a Subscript node by returning a fresh instance of it."""
1621 context = self._get_context(node)
1622 newnode = nodes.Subscript(
1623 ctx=context,
1624 lineno=node.lineno,
1625 col_offset=node.col_offset,
1626 end_lineno=node.end_lineno,
1627 end_col_offset=node.end_col_offset,
1628 parent=parent,
1629 )
1630 newnode.postinit(
1631 self.visit(node.value, newnode), self.visit(node.slice, newnode)
1632 )
1633 return newnode
1635 def visit_starred(self, node: ast.Starred, parent: nodes.NodeNG) -> nodes.Starred:
1636 """Visit a Starred node and return a new instance of it."""
1637 context = self._get_context(node)
1638 newnode = nodes.Starred(
1639 ctx=context,
1640 lineno=node.lineno,
1641 col_offset=node.col_offset,
1642 end_lineno=node.end_lineno,
1643 end_col_offset=node.end_col_offset,
1644 parent=parent,
1645 )
1646 newnode.postinit(self.visit(node.value, newnode))
1647 return newnode
1649 def visit_try(self, node: ast.Try, parent: nodes.NodeNG) -> nodes.Try:
1650 """Visit a Try node by returning a fresh instance of it"""
1651 newnode = nodes.Try(
1652 lineno=node.lineno,
1653 col_offset=node.col_offset,
1654 end_lineno=node.end_lineno,
1655 end_col_offset=node.end_col_offset,
1656 parent=parent,
1657 )
1658 newnode.postinit(
1659 body=[self.visit(child, newnode) for child in node.body],
1660 handlers=[self.visit(child, newnode) for child in node.handlers],
1661 orelse=[self.visit(child, newnode) for child in node.orelse],
1662 finalbody=[self.visit(child, newnode) for child in node.finalbody],
1663 )
1664 return newnode
1666 def visit_trystar(self, node: ast.TryStar, parent: nodes.NodeNG) -> nodes.TryStar:
1667 newnode = nodes.TryStar(
1668 lineno=node.lineno,
1669 col_offset=node.col_offset,
1670 end_lineno=node.end_lineno,
1671 end_col_offset=node.end_col_offset,
1672 parent=parent,
1673 )
1674 newnode.postinit(
1675 body=[self.visit(n, newnode) for n in node.body],
1676 handlers=[self.visit(n, newnode) for n in node.handlers],
1677 orelse=[self.visit(n, newnode) for n in node.orelse],
1678 finalbody=[self.visit(n, newnode) for n in node.finalbody],
1679 )
1680 return newnode
1682 def visit_tuple(self, node: ast.Tuple, parent: nodes.NodeNG) -> nodes.Tuple:
1683 """Visit a Tuple node by returning a fresh instance of it."""
1684 context = self._get_context(node)
1685 newnode = nodes.Tuple(
1686 ctx=context,
1687 lineno=node.lineno,
1688 col_offset=node.col_offset,
1689 end_lineno=node.end_lineno,
1690 end_col_offset=node.end_col_offset,
1691 parent=parent,
1692 )
1693 newnode.postinit([self.visit(child, newnode) for child in node.elts])
1694 return newnode
1696 def visit_typealias(
1697 self, node: ast.TypeAlias, parent: nodes.NodeNG
1698 ) -> nodes.TypeAlias:
1699 """Visit a TypeAlias node by returning a fresh instance of it."""
1700 newnode = nodes.TypeAlias(
1701 lineno=node.lineno,
1702 col_offset=node.col_offset,
1703 end_lineno=node.end_lineno,
1704 end_col_offset=node.end_col_offset,
1705 parent=parent,
1706 )
1707 newnode.postinit(
1708 name=self.visit(node.name, newnode),
1709 type_params=[self.visit(p, newnode) for p in node.type_params],
1710 value=self.visit(node.value, newnode),
1711 )
1712 return newnode
1714 def visit_typevar(self, node: ast.TypeVar, parent: nodes.NodeNG) -> nodes.TypeVar:
1715 """Visit a TypeVar node by returning a fresh instance of it."""
1716 newnode = nodes.TypeVar(
1717 lineno=node.lineno,
1718 col_offset=node.col_offset,
1719 end_lineno=node.end_lineno,
1720 end_col_offset=node.end_col_offset,
1721 parent=parent,
1722 )
1723 # Add AssignName node for 'node.name'
1724 # https://bugs.python.org/issue43994
1725 newnode.postinit(
1726 name=self.visit_assignname(node, newnode, node.name),
1727 bound=self.visit(node.bound, newnode),
1728 default_value=(
1729 self.visit(node.default_value, newnode) if PY313_PLUS else None
1730 ),
1731 )
1732 return newnode
1734 def visit_typevartuple(
1735 self, node: ast.TypeVarTuple, parent: nodes.NodeNG
1736 ) -> nodes.TypeVarTuple:
1737 """Visit a TypeVarTuple node by returning a fresh instance of it."""
1738 newnode = nodes.TypeVarTuple(
1739 lineno=node.lineno,
1740 col_offset=node.col_offset,
1741 end_lineno=node.end_lineno,
1742 end_col_offset=node.end_col_offset,
1743 parent=parent,
1744 )
1745 # Add AssignName node for 'node.name'
1746 # https://bugs.python.org/issue43994
1747 newnode.postinit(
1748 name=self.visit_assignname(node, newnode, node.name),
1749 default_value=(
1750 self.visit(node.default_value, newnode) if PY313_PLUS else None
1751 ),
1752 )
1753 return newnode
1755 def visit_unaryop(self, node: ast.UnaryOp, parent: nodes.NodeNG) -> nodes.UnaryOp:
1756 """Visit a UnaryOp node by returning a fresh instance of it."""
1757 newnode = nodes.UnaryOp(
1758 op=UNARY_OP_CLASSES[node.op.__class__],
1759 lineno=node.lineno,
1760 col_offset=node.col_offset,
1761 end_lineno=node.end_lineno,
1762 end_col_offset=node.end_col_offset,
1763 parent=parent,
1764 )
1765 newnode.postinit(self.visit(node.operand, newnode))
1766 return newnode
1768 def visit_while(self, node: ast.While, parent: nodes.NodeNG) -> nodes.While:
1769 """Visit a While node by returning a fresh instance of it."""
1770 newnode = nodes.While(
1771 lineno=node.lineno,
1772 col_offset=node.col_offset,
1773 end_lineno=node.end_lineno,
1774 end_col_offset=node.end_col_offset,
1775 parent=parent,
1776 )
1777 newnode.postinit(
1778 self.visit(node.test, newnode),
1779 [self.visit(child, newnode) for child in node.body],
1780 [self.visit(child, newnode) for child in node.orelse],
1781 )
1782 return newnode
1784 @overload
1785 def _visit_with(
1786 self, cls: type[nodes.With], node: ast.With, parent: nodes.NodeNG
1787 ) -> nodes.With: ...
1789 @overload
1790 def _visit_with(
1791 self, cls: type[nodes.AsyncWith], node: ast.AsyncWith, parent: nodes.NodeNG
1792 ) -> nodes.AsyncWith: ...
1794 def _visit_with(
1795 self,
1796 cls: type[_WithT],
1797 node: ast.With | ast.AsyncWith,
1798 parent: nodes.NodeNG,
1799 ) -> _WithT:
1800 newnode = cls(
1801 lineno=node.lineno,
1802 col_offset=node.col_offset,
1803 end_lineno=node.end_lineno,
1804 end_col_offset=node.end_col_offset,
1805 parent=parent,
1806 )
1808 def visit_child(
1809 child: ast.withitem,
1810 ) -> tuple[nodes.NodeNG, nodes.NodeNG | None]:
1811 expr = self.visit(child.context_expr, newnode)
1812 var = self.visit(child.optional_vars, newnode)
1813 return expr, var
1815 type_annotation = self.check_type_comment(node, parent=newnode)
1816 newnode.postinit(
1817 items=[visit_child(child) for child in node.items],
1818 body=[self.visit(child, newnode) for child in node.body],
1819 type_annotation=type_annotation,
1820 )
1821 return newnode
1823 def visit_with(self, node: ast.With, parent: nodes.NodeNG) -> nodes.NodeNG:
1824 return self._visit_with(nodes.With, node, parent)
1826 def visit_yield(self, node: ast.Yield, parent: nodes.NodeNG) -> nodes.NodeNG:
1827 """Visit a Yield node by returning a fresh instance of it."""
1828 newnode = nodes.Yield(
1829 lineno=node.lineno,
1830 col_offset=node.col_offset,
1831 end_lineno=node.end_lineno,
1832 end_col_offset=node.end_col_offset,
1833 parent=parent,
1834 )
1835 newnode.postinit(self.visit(node.value, newnode))
1836 return newnode
1838 def visit_yieldfrom(
1839 self, node: ast.YieldFrom, parent: nodes.NodeNG
1840 ) -> nodes.NodeNG:
1841 newnode = nodes.YieldFrom(
1842 lineno=node.lineno,
1843 col_offset=node.col_offset,
1844 end_lineno=node.end_lineno,
1845 end_col_offset=node.end_col_offset,
1846 parent=parent,
1847 )
1848 newnode.postinit(self.visit(node.value, newnode))
1849 return newnode
1851 def visit_match(self, node: ast.Match, parent: nodes.NodeNG) -> nodes.Match:
1852 newnode = nodes.Match(
1853 lineno=node.lineno,
1854 col_offset=node.col_offset,
1855 end_lineno=node.end_lineno,
1856 end_col_offset=node.end_col_offset,
1857 parent=parent,
1858 )
1859 newnode.postinit(
1860 subject=self.visit(node.subject, newnode),
1861 cases=[self.visit(case, newnode) for case in node.cases],
1862 )
1863 return newnode
1865 def visit_matchcase(
1866 self, node: ast.match_case, parent: nodes.NodeNG
1867 ) -> nodes.MatchCase:
1868 newnode = nodes.MatchCase(parent=parent)
1869 newnode.postinit(
1870 pattern=self.visit(node.pattern, newnode),
1871 guard=self.visit(node.guard, newnode),
1872 body=[self.visit(child, newnode) for child in node.body],
1873 )
1874 return newnode
1876 def visit_matchvalue(
1877 self, node: ast.MatchValue, parent: nodes.NodeNG
1878 ) -> nodes.MatchValue:
1879 newnode = nodes.MatchValue(
1880 lineno=node.lineno,
1881 col_offset=node.col_offset,
1882 end_lineno=node.end_lineno,
1883 end_col_offset=node.end_col_offset,
1884 parent=parent,
1885 )
1886 newnode.postinit(value=self.visit(node.value, newnode))
1887 return newnode
1889 def visit_matchsingleton(
1890 self, node: ast.MatchSingleton, parent: nodes.NodeNG
1891 ) -> nodes.MatchSingleton:
1892 return nodes.MatchSingleton(
1893 value=node.value,
1894 lineno=node.lineno,
1895 col_offset=node.col_offset,
1896 end_lineno=node.end_lineno,
1897 end_col_offset=node.end_col_offset,
1898 parent=parent,
1899 )
1901 def visit_matchsequence(
1902 self, node: ast.MatchSequence, parent: nodes.NodeNG
1903 ) -> nodes.MatchSequence:
1904 newnode = nodes.MatchSequence(
1905 lineno=node.lineno,
1906 col_offset=node.col_offset,
1907 end_lineno=node.end_lineno,
1908 end_col_offset=node.end_col_offset,
1909 parent=parent,
1910 )
1911 newnode.postinit(
1912 patterns=[self.visit(pattern, newnode) for pattern in node.patterns]
1913 )
1914 return newnode
1916 def visit_matchmapping(
1917 self, node: ast.MatchMapping, parent: nodes.NodeNG
1918 ) -> nodes.MatchMapping:
1919 newnode = nodes.MatchMapping(
1920 lineno=node.lineno,
1921 col_offset=node.col_offset,
1922 end_lineno=node.end_lineno,
1923 end_col_offset=node.end_col_offset,
1924 parent=parent,
1925 )
1926 # Add AssignName node for 'node.name'
1927 # https://bugs.python.org/issue43994
1928 newnode.postinit(
1929 keys=[self.visit(child, newnode) for child in node.keys],
1930 patterns=[self.visit(pattern, newnode) for pattern in node.patterns],
1931 rest=self.visit_assignname(node, newnode, node.rest),
1932 )
1933 return newnode
1935 def visit_matchclass(
1936 self, node: ast.MatchClass, parent: nodes.NodeNG
1937 ) -> nodes.MatchClass:
1938 newnode = nodes.MatchClass(
1939 lineno=node.lineno,
1940 col_offset=node.col_offset,
1941 end_lineno=node.end_lineno,
1942 end_col_offset=node.end_col_offset,
1943 parent=parent,
1944 )
1945 newnode.postinit(
1946 cls=self.visit(node.cls, newnode),
1947 patterns=[self.visit(pattern, newnode) for pattern in node.patterns],
1948 kwd_attrs=node.kwd_attrs,
1949 kwd_patterns=[
1950 self.visit(pattern, newnode) for pattern in node.kwd_patterns
1951 ],
1952 )
1953 return newnode
1955 def visit_matchstar(
1956 self, node: ast.MatchStar, parent: nodes.NodeNG
1957 ) -> nodes.MatchStar:
1958 newnode = nodes.MatchStar(
1959 lineno=node.lineno,
1960 col_offset=node.col_offset,
1961 end_lineno=node.end_lineno,
1962 end_col_offset=node.end_col_offset,
1963 parent=parent,
1964 )
1965 # Add AssignName node for 'node.name'
1966 # https://bugs.python.org/issue43994
1967 newnode.postinit(name=self.visit_assignname(node, newnode, node.name))
1968 return newnode
1970 def visit_matchas(self, node: ast.MatchAs, parent: nodes.NodeNG) -> nodes.MatchAs:
1971 newnode = nodes.MatchAs(
1972 lineno=node.lineno,
1973 col_offset=node.col_offset,
1974 end_lineno=node.end_lineno,
1975 end_col_offset=node.end_col_offset,
1976 parent=parent,
1977 )
1978 # Add AssignName node for 'node.name'
1979 # https://bugs.python.org/issue43994
1980 newnode.postinit(
1981 pattern=self.visit(node.pattern, newnode),
1982 name=self.visit_assignname(node, newnode, node.name),
1983 )
1984 return newnode
1986 def visit_matchor(self, node: ast.MatchOr, parent: nodes.NodeNG) -> nodes.MatchOr:
1987 newnode = nodes.MatchOr(
1988 lineno=node.lineno,
1989 col_offset=node.col_offset,
1990 end_lineno=node.end_lineno,
1991 end_col_offset=node.end_col_offset,
1992 parent=parent,
1993 )
1994 newnode.postinit(
1995 patterns=[self.visit(pattern, newnode) for pattern in node.patterns]
1996 )
1997 return newnode
1999 if sys.version_info >= (3, 14):
2001 def visit_templatestr(
2002 self, node: ast.TemplateStr, parent: nodes.NodeNG
2003 ) -> nodes.TemplateStr:
2004 newnode = nodes.TemplateStr(
2005 lineno=node.lineno,
2006 col_offset=node.col_offset,
2007 end_lineno=node.end_lineno,
2008 end_col_offset=node.end_col_offset,
2009 parent=parent,
2010 )
2011 newnode.postinit(
2012 values=[self.visit(value, newnode) for value in node.values]
2013 )
2014 return newnode
2016 def visit_interpolation(
2017 self, node: ast.Interpolation, parent: nodes.NodeNG
2018 ) -> nodes.Interpolation:
2019 newnode = nodes.Interpolation(
2020 lineno=node.lineno,
2021 col_offset=node.col_offset,
2022 end_lineno=node.end_lineno,
2023 end_col_offset=node.end_col_offset,
2024 parent=parent,
2025 )
2026 newnode.postinit(
2027 value=self.visit(node.value, parent),
2028 str=node.str,
2029 conversion=node.conversion,
2030 format_spec=self.visit(node.format_spec, parent),
2031 )
2032 return newnode