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

699 statements  

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 

4 

5"""This module contains utilities for rebuilding an _ast tree in 

6order to get a single Astroid representation. 

7""" 

8 

9from __future__ import annotations 

10 

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 

19 

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 

32 

33if TYPE_CHECKING: 

34 from astroid.manager import AstroidManager 

35 

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 

46 

47 

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} 

57 

58 

59# noinspection PyMethodMayBeStatic 

60class TreeRebuilder: 

61 """Rebuilds the _ast tree to become an Astroid tree.""" 

62 

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 ] = {} 

78 

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 

93 

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) 

106 

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. 

113 

114 In contrast to AST positions, these only include the actual keyword(s) 

115 and the class / function name. 

116 

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]) 

127 

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" 

136 

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 

161 

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 ) 

168 

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. 

173 

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 

189 

190 if TYPE_CHECKING: # noqa: C901 

191 

192 @overload 

193 def visit(self, node: ast.arg, parent: nodes.NodeNG) -> nodes.AssignName: ... 

194 

195 @overload 

196 def visit( 

197 self, node: ast.arguments, parent: nodes.NodeNG 

198 ) -> nodes.Arguments: ... 

199 

200 @overload 

201 def visit(self, node: ast.Assert, parent: nodes.NodeNG) -> nodes.Assert: ... 

202 

203 @overload 

204 def visit( 

205 self, node: ast.AsyncFunctionDef, parent: nodes.NodeNG 

206 ) -> nodes.AsyncFunctionDef: ... 

207 

208 @overload 

209 def visit(self, node: ast.AsyncFor, parent: nodes.NodeNG) -> nodes.AsyncFor: ... 

210 

211 @overload 

212 def visit(self, node: ast.Await, parent: nodes.NodeNG) -> nodes.Await: ... 

213 

214 @overload 

215 def visit( 

216 self, node: ast.AsyncWith, parent: nodes.NodeNG 

217 ) -> nodes.AsyncWith: ... 

218 

219 @overload 

220 def visit(self, node: ast.Assign, parent: nodes.NodeNG) -> nodes.Assign: ... 

221 

222 @overload 

223 def visit( 

224 self, node: ast.AnnAssign, parent: nodes.NodeNG 

225 ) -> nodes.AnnAssign: ... 

226 

227 @overload 

228 def visit( 

229 self, node: ast.AugAssign, parent: nodes.NodeNG 

230 ) -> nodes.AugAssign: ... 

231 

232 @overload 

233 def visit(self, node: ast.BinOp, parent: nodes.NodeNG) -> nodes.BinOp: ... 

234 

235 @overload 

236 def visit(self, node: ast.BoolOp, parent: nodes.NodeNG) -> nodes.BoolOp: ... 

237 

238 @overload 

239 def visit(self, node: ast.Break, parent: nodes.NodeNG) -> nodes.Break: ... 

240 

241 @overload 

242 def visit(self, node: ast.Call, parent: nodes.NodeNG) -> nodes.Call: ... 

243 

244 @overload 

245 def visit(self, node: ast.ClassDef, parent: nodes.NodeNG) -> nodes.ClassDef: ... 

246 

247 @overload 

248 def visit(self, node: ast.Continue, parent: nodes.NodeNG) -> nodes.Continue: ... 

249 

250 @overload 

251 def visit(self, node: ast.Compare, parent: nodes.NodeNG) -> nodes.Compare: ... 

252 

253 @overload 

254 def visit( 

255 self, node: ast.comprehension, parent: nodes.NodeNG 

256 ) -> nodes.Comprehension: ... 

257 

258 @overload 

259 def visit(self, node: ast.Delete, parent: nodes.NodeNG) -> nodes.Delete: ... 

260 

261 @overload 

262 def visit(self, node: ast.Dict, parent: nodes.NodeNG) -> nodes.Dict: ... 

263 

264 @overload 

265 def visit(self, node: ast.DictComp, parent: nodes.NodeNG) -> nodes.DictComp: ... 

266 

267 @overload 

268 def visit(self, node: ast.Expr, parent: nodes.NodeNG) -> nodes.Expr: ... 

269 

270 @overload 

271 def visit( 

272 self, node: ast.ExceptHandler, parent: nodes.NodeNG 

273 ) -> nodes.ExceptHandler: ... 

274 

275 @overload 

276 def visit(self, node: ast.For, parent: nodes.NodeNG) -> nodes.For: ... 

277 

278 @overload 

279 def visit( 

280 self, node: ast.ImportFrom, parent: nodes.NodeNG 

281 ) -> nodes.ImportFrom: ... 

282 

283 @overload 

284 def visit( 

285 self, node: ast.FunctionDef, parent: nodes.NodeNG 

286 ) -> nodes.FunctionDef: ... 

287 

288 @overload 

289 def visit( 

290 self, node: ast.GeneratorExp, parent: nodes.NodeNG 

291 ) -> nodes.GeneratorExp: ... 

292 

293 @overload 

294 def visit( 

295 self, node: ast.Attribute, parent: nodes.NodeNG 

296 ) -> nodes.Attribute: ... 

297 

298 @overload 

299 def visit(self, node: ast.Global, parent: nodes.NodeNG) -> nodes.Global: ... 

300 

301 @overload 

302 def visit(self, node: ast.If, parent: nodes.NodeNG) -> nodes.If: ... 

303 

304 @overload 

305 def visit(self, node: ast.IfExp, parent: nodes.NodeNG) -> nodes.IfExp: ... 

306 

307 @overload 

308 def visit(self, node: ast.Import, parent: nodes.NodeNG) -> nodes.Import: ... 

309 

310 @overload 

311 def visit( 

312 self, node: ast.JoinedStr, parent: nodes.NodeNG 

313 ) -> nodes.JoinedStr: ... 

314 

315 @overload 

316 def visit( 

317 self, node: ast.FormattedValue, parent: nodes.NodeNG 

318 ) -> nodes.FormattedValue: ... 

319 

320 @overload 

321 def visit( 

322 self, node: ast.NamedExpr, parent: nodes.NodeNG 

323 ) -> nodes.NamedExpr: ... 

324 

325 @overload 

326 def visit(self, node: ast.keyword, parent: nodes.NodeNG) -> nodes.Keyword: ... 

327 

328 @overload 

329 def visit(self, node: ast.Lambda, parent: nodes.NodeNG) -> nodes.Lambda: ... 

330 

331 @overload 

332 def visit(self, node: ast.List, parent: nodes.NodeNG) -> nodes.List: ... 

333 

334 @overload 

335 def visit(self, node: ast.ListComp, parent: nodes.NodeNG) -> nodes.ListComp: ... 

336 

337 @overload 

338 def visit( 

339 self, node: ast.Name, parent: nodes.NodeNG 

340 ) -> nodes.Name | nodes.Const | nodes.AssignName | nodes.DelName: ... 

341 

342 @overload 

343 def visit(self, node: ast.Nonlocal, parent: nodes.NodeNG) -> nodes.Nonlocal: ... 

344 

345 @overload 

346 def visit(self, node: ast.Constant, parent: nodes.NodeNG) -> nodes.Const: ... 

347 

348 if sys.version_info >= (3, 12): 

349 

350 @overload 

351 def visit( 

352 self, node: ast.ParamSpec, parent: nodes.NodeNG 

353 ) -> nodes.ParamSpec: ... 

354 

355 @overload 

356 def visit(self, node: ast.Pass, parent: nodes.NodeNG) -> nodes.Pass: ... 

357 

358 @overload 

359 def visit(self, node: ast.Raise, parent: nodes.NodeNG) -> nodes.Raise: ... 

360 

361 @overload 

362 def visit(self, node: ast.Return, parent: nodes.NodeNG) -> nodes.Return: ... 

363 

364 @overload 

365 def visit(self, node: ast.Set, parent: nodes.NodeNG) -> nodes.Set: ... 

366 

367 @overload 

368 def visit(self, node: ast.SetComp, parent: nodes.NodeNG) -> nodes.SetComp: ... 

369 

370 @overload 

371 def visit(self, node: ast.Slice, parent: nodes.Subscript) -> nodes.Slice: ... 

372 

373 @overload 

374 def visit( 

375 self, node: ast.Subscript, parent: nodes.NodeNG 

376 ) -> nodes.Subscript: ... 

377 

378 @overload 

379 def visit(self, node: ast.Starred, parent: nodes.NodeNG) -> nodes.Starred: ... 

380 

381 @overload 

382 def visit(self, node: ast.Try, parent: nodes.NodeNG) -> nodes.Try: ... 

383 

384 @overload 

385 def visit(self, node: ast.TryStar, parent: nodes.NodeNG) -> nodes.TryStar: ... 

386 

387 @overload 

388 def visit(self, node: ast.Tuple, parent: nodes.NodeNG) -> nodes.Tuple: ... 

389 

390 if sys.version_info >= (3, 12): 

391 

392 @overload 

393 def visit( 

394 self, node: ast.TypeAlias, parent: nodes.NodeNG 

395 ) -> nodes.TypeAlias: ... 

396 

397 @overload 

398 def visit( 

399 self, node: ast.TypeVar, parent: nodes.NodeNG 

400 ) -> nodes.TypeVar: ... 

401 

402 @overload 

403 def visit( 

404 self, node: ast.TypeVarTuple, parent: nodes.NodeNG 

405 ) -> nodes.TypeVarTuple: ... 

406 

407 @overload 

408 def visit(self, node: ast.UnaryOp, parent: nodes.NodeNG) -> nodes.UnaryOp: ... 

409 

410 @overload 

411 def visit(self, node: ast.While, parent: nodes.NodeNG) -> nodes.While: ... 

412 

413 @overload 

414 def visit(self, node: ast.With, parent: nodes.NodeNG) -> nodes.With: ... 

415 

416 @overload 

417 def visit(self, node: ast.Yield, parent: nodes.NodeNG) -> nodes.Yield: ... 

418 

419 @overload 

420 def visit( 

421 self, node: ast.YieldFrom, parent: nodes.NodeNG 

422 ) -> nodes.YieldFrom: ... 

423 

424 @overload 

425 def visit(self, node: ast.Match, parent: nodes.NodeNG) -> nodes.Match: ... 

426 

427 @overload 

428 def visit( 

429 self, node: ast.match_case, parent: nodes.NodeNG 

430 ) -> nodes.MatchCase: ... 

431 

432 @overload 

433 def visit( 

434 self, node: ast.MatchValue, parent: nodes.NodeNG 

435 ) -> nodes.MatchValue: ... 

436 

437 @overload 

438 def visit( 

439 self, node: ast.MatchSingleton, parent: nodes.NodeNG 

440 ) -> nodes.MatchSingleton: ... 

441 

442 @overload 

443 def visit( 

444 self, node: ast.MatchSequence, parent: nodes.NodeNG 

445 ) -> nodes.MatchSequence: ... 

446 

447 @overload 

448 def visit( 

449 self, node: ast.MatchMapping, parent: nodes.NodeNG 

450 ) -> nodes.MatchMapping: ... 

451 

452 @overload 

453 def visit( 

454 self, node: ast.MatchClass, parent: nodes.NodeNG 

455 ) -> nodes.MatchClass: ... 

456 

457 @overload 

458 def visit( 

459 self, node: ast.MatchStar, parent: nodes.NodeNG 

460 ) -> nodes.MatchStar: ... 

461 

462 @overload 

463 def visit(self, node: ast.MatchAs, parent: nodes.NodeNG) -> nodes.MatchAs: ... 

464 

465 @overload 

466 def visit(self, node: ast.MatchOr, parent: nodes.NodeNG) -> nodes.MatchOr: ... 

467 

468 @overload 

469 def visit(self, node: ast.pattern, parent: nodes.NodeNG) -> nodes.Pattern: ... 

470 

471 if sys.version_info >= (3, 14): 

472 

473 @overload 

474 def visit( 

475 self, node: ast.TemplateStr, parent: nodes.NodeNG 

476 ) -> nodes.TemplateStr: ... 

477 

478 @overload 

479 def visit( 

480 self, node: ast.Interpolation, parent: nodes.NodeNG 

481 ) -> nodes.Interpolation: ... 

482 

483 @overload 

484 def visit(self, node: ast.AST, parent: nodes.NodeNG) -> nodes.NodeNG: ... 

485 

486 @overload 

487 def visit(self, node: None, parent: nodes.NodeNG) -> None: ... 

488 

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) 

501 

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) 

510 

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) 

514 

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 

523 

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) 

563 

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 ] 

570 

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 ] 

584 

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) 

609 

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 

617 

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 

632 

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 

647 

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 

655 

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 

660 

661 type_object = self.visit(type_comment_ast.body[0], parent=parent) 

662 if not isinstance(type_object, nodes.Expr): 

663 return None 

664 

665 return type_object.value 

666 

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 

672 

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 

680 

681 if not type_comment_ast: 

682 return None 

683 

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) 

690 

691 return returns, argtypes 

692 

693 def visit_asyncfunctiondef( 

694 self, node: ast.AsyncFunctionDef, parent: nodes.NodeNG 

695 ) -> nodes.AsyncFunctionDef: 

696 return self._visit_functiondef(nodes.AsyncFunctionDef, node, parent) 

697 

698 def visit_asyncfor( 

699 self, node: ast.AsyncFor, parent: nodes.NodeNG 

700 ) -> nodes.AsyncFor: 

701 return self._visit_for(nodes.AsyncFor, node, parent) 

702 

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 

713 

714 def visit_asyncwith( 

715 self, node: ast.AsyncWith, parent: nodes.NodeNG 

716 ) -> nodes.AsyncWith: 

717 return self._visit_with(nodes.AsyncWith, node, parent) 

718 

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 

735 

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 

754 

755 @overload 

756 def visit_assignname( 

757 self, node: ast.AST, parent: nodes.NodeNG, node_name: str 

758 ) -> nodes.AssignName: ... 

759 

760 @overload 

761 def visit_assignname( 

762 self, node: ast.AST, parent: nodes.NodeNG, node_name: None 

763 ) -> None: ... 

764 

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. 

769 

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 

784 

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 

801 

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 

816 

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 

829 

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 ) 

839 

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 

855 

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 

895 

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 ) 

907 

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 

928 

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 

949 

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. 

956 

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 

963 

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 

967 

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 

977 

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 

989 

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 

1008 

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 

1023 

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 

1058 

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 

1070 

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 

1088 

1089 @overload 

1090 def _visit_for( 

1091 self, cls: type[nodes.For], node: ast.For, parent: nodes.NodeNG 

1092 ) -> nodes.For: ... 

1093 

1094 @overload 

1095 def _visit_for( 

1096 self, cls: type[nodes.AsyncFor], node: ast.AsyncFor, parent: nodes.NodeNG 

1097 ) -> nodes.AsyncFor: ... 

1098 

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 

1119 

1120 def visit_for(self, node: ast.For, parent: nodes.NodeNG) -> nodes.For: 

1121 return self._visit_for(nodes.For, node, parent) 

1122 

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 

1144 

1145 @overload 

1146 def _visit_functiondef( 

1147 self, cls: type[nodes.FunctionDef], node: ast.FunctionDef, parent: nodes.NodeNG 

1148 ) -> nodes.FunctionDef: ... 

1149 

1150 @overload 

1151 def _visit_functiondef( 

1152 self, 

1153 cls: type[nodes.AsyncFunctionDef], 

1154 node: ast.AsyncFunctionDef, 

1155 parent: nodes.NodeNG, 

1156 ) -> nodes.AsyncFunctionDef: ... 

1157 

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) 

1167 

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 

1177 

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 

1192 

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 

1215 

1216 def visit_functiondef( 

1217 self, node: ast.FunctionDef, parent: nodes.NodeNG 

1218 ) -> nodes.FunctionDef: 

1219 return self._visit_functiondef(nodes.FunctionDef, node, parent) 

1220 

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 

1237 

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 

1281 

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 

1296 

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 

1312 

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 

1328 

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 

1349 

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 

1362 

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 

1379 

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 

1394 

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 

1407 

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 

1419 

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 

1433 

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 

1450 

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 

1489 

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 ) 

1502 

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 ) 

1514 

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 

1535 

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 ) 

1545 

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 

1561 

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 

1573 

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 

1585 

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 

1600 

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 

1616 

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 

1634 

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 

1648 

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 

1665 

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 

1681 

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 

1695 

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 

1713 

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 

1733 

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 

1754 

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 

1767 

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 

1783 

1784 @overload 

1785 def _visit_with( 

1786 self, cls: type[nodes.With], node: ast.With, parent: nodes.NodeNG 

1787 ) -> nodes.With: ... 

1788 

1789 @overload 

1790 def _visit_with( 

1791 self, cls: type[nodes.AsyncWith], node: ast.AsyncWith, parent: nodes.NodeNG 

1792 ) -> nodes.AsyncWith: ... 

1793 

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 ) 

1807 

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 

1814 

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 

1822 

1823 def visit_with(self, node: ast.With, parent: nodes.NodeNG) -> nodes.NodeNG: 

1824 return self._visit_with(nodes.With, node, parent) 

1825 

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 

1837 

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 

1850 

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 

1864 

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 

1875 

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 

1888 

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 ) 

1900 

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 

1915 

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 

1934 

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 

1954 

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 

1969 

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 

1985 

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 

1998 

1999 if sys.version_info >= (3, 14): 

2000 

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 

2015 

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