astroid.rebuilder.TreeRebuilder

class documentation

class TreeRebuilder: (source)

Constructor: TreeRebuilder(manager, parser_module)

View In Hierarchy

Rebuilds the _ast tree to become an Astroid tree

Method __init__ Undocumented
Method check_function_type_comment Undocumented
Method check_type_comment Undocumented
Method visit Undocumented
Method visit_annassign visit an AnnAssign node by returning a fresh instance of it
Method visit_arg visit an arg node by returning a fresh AssName instance
Method visit_arguments visit an Arguments node by returning a fresh instance of it
Method visit_assert visit a Assert node by returning a fresh instance of it
Method visit_assign visit a Assign node by returning a fresh instance of it
Method visit_assignname visit a node and return a AssignName node
Method visit_asyncfor Undocumented
Method visit_asyncfunctiondef Undocumented
Method visit_asyncwith Undocumented
Method visit_attribute visit an Attribute node by returning a fresh instance of it
Method visit_augassign visit a AugAssign node by returning a fresh instance of it
Method visit_await Undocumented
Method visit_binop visit a BinOp node by returning a fresh instance of it
Method visit_boolop visit a BoolOp node by returning a fresh instance of it
Method visit_break visit a Break node by returning a fresh instance of it
Method visit_call visit a CallFunc node by returning a fresh instance of it
Method visit_classdef visit a ClassDef node to become astroid
Method visit_compare visit a Compare node by returning a fresh instance of it
Method visit_comprehension visit a Comprehension node by returning a fresh instance of it
Method visit_constant visit a Constant node by returning a fresh instance of Const
Method visit_continue visit a Continue node by returning a fresh instance of it
Method visit_decorators visit a Decorators node by returning a fresh instance of it
Method visit_delete visit a Delete node by returning a fresh instance of it
Method visit_dict visit a Dict node by returning a fresh instance of it
Method visit_dictcomp visit a DictComp node by returning a fresh instance of it
Method visit_ellipsis visit an Ellipsis node by returning a fresh instance of Const
Method visit_excepthandler visit an ExceptHandler node by returning a fresh instance of it
Method visit_expr visit a Expr node by returning a fresh instance of it
Method visit_extslice visit an ExtSlice node by returning a fresh instance of Tuple
Method visit_for Undocumented
Method visit_formattedvalue Undocumented
Method visit_functiondef Undocumented
Method visit_generatorexp visit a GeneratorExp node by returning a fresh instance of it
Method visit_global visit a Global node to become astroid
Method visit_if visit an If node by returning a fresh instance of it
Method visit_ifexp visit a IfExp node by returning a fresh instance of it
Method visit_import visit a Import node by returning a fresh instance of it
Method visit_importfrom visit an ImportFrom node by returning a fresh instance of it
Method visit_index visit a Index node by returning a fresh instance of NodeNG
Method visit_joinedstr Undocumented
Method visit_keyword visit a Keyword node by returning a fresh instance of it
Method visit_lambda visit a Lambda node by returning a fresh instance of it
Method visit_list visit a List node by returning a fresh instance of it
Method visit_listcomp visit a ListComp node by returning a fresh instance of it
Method visit_match Undocumented
Method visit_matchas Undocumented
Method visit_matchcase Undocumented
Method visit_matchclass Undocumented
Method visit_matchmapping Undocumented
Method visit_matchor Undocumented
Method visit_matchsequence Undocumented
Method visit_matchsingleton Undocumented
Method visit_matchstar Undocumented
Method visit_matchvalue Undocumented
Method visit_module visit a Module node by returning a fresh instance of it
Method visit_name visit a Name node by returning a fresh instance of it
Method visit_nameconstant Undocumented
Method visit_namedexpr Undocumented
Method visit_nonlocal visit a Nonlocal node and return a new instance of it
Method visit_num visit a Num node by returning a fresh instance of Const
Method visit_pass visit a Pass node by returning a fresh instance of it
Method visit_raise visit a Raise node by returning a fresh instance of it
Method visit_return visit a Return node by returning a fresh instance of it
Method visit_set visit a Set node by returning a fresh instance of it
Method visit_setcomp visit a SetComp node by returning a fresh instance of it
Method visit_slice visit a Slice node by returning a fresh instance of it
Method visit_starred visit a Starred node and return a new instance of it
Method visit_str visit a String/Bytes node by returning a fresh instance of Const
Method visit_subscript visit a Subscript node by returning a fresh instance of it
Method visit_try Undocumented
Method visit_tryexcept visit a TryExcept node by returning a fresh instance of it
Method visit_tryfinally visit a TryFinally node by returning a fresh instance of it
Method visit_tuple visit a Tuple node by returning a fresh instance of it
Method visit_unaryop visit a UnaryOp node by returning a fresh instance of it
Method visit_while visit a While node by returning a fresh instance of it
Method visit_with Undocumented
Method visit_yield visit a Yield node by returning a fresh instance of it
Method visit_yieldfrom Undocumented
Method _get_context Undocumented
Method _get_doc Undocumented
Method _save_assignment save assignment situation since node.parent is not available yet
Method _visit_dict_items Undocumented
Method _visit_for visit a For node by returning a fresh instance of it
Method _visit_functiondef visit an FunctionDef node to become astroid
Method _visit_with Undocumented
Instance Variable _delayed_assattr Undocumented
Instance Variable _global_names Undocumented
Instance Variable _import_from_nodes Undocumented
Instance Variable _manager Undocumented
Instance Variable _module Undocumented
Instance Variable _parser_module Undocumented
Instance Variable _visit_meths Undocumented
def __init__(self, manager: AstroidManager, parser_module: ParserModule | None = None): (source)

Undocumented

def check_function_type_comment(self, node: ast.FunctionDef | ast.AsyncFunctionDef, parent: NodeNG) -> tuple[NodeNG | None, list[NodeNG]] | None: (source)

Undocumented

def check_type_comment(self, node: ast.Assign | ast.arg | ast.For | ast.AsyncFor | ast.With | ast.AsyncWith, parent: nodes.Assign | nodes.Arguments | nodes.For | nodes.AsyncFor | nodes.With | nodes.AsyncWith) -> NodeNG | None: (source)

Undocumented

@overload
def visit(self, node: ast.arg, parent: NodeNG) -> nodes.AssignName:
@overload
def visit(self, node: ast.arguments, parent: NodeNG) -> nodes.Arguments:
@overload
def visit(self, node: ast.Assert, parent: NodeNG) -> nodes.Assert:
@overload
def visit(self, node: ast.AsyncFunctionDef, parent: NodeNG) -> nodes.AsyncFunctionDef:
@overload
def visit(self, node: ast.AsyncFor, parent: NodeNG) -> nodes.AsyncFor:
@overload
def visit(self, node: ast.Await, parent: NodeNG) -> nodes.Await:
@overload
def visit(self, node: ast.AsyncWith, parent: NodeNG) -> nodes.AsyncWith:
@overload
def visit(self, node: ast.Assign, parent: NodeNG) -> nodes.Assign:
@overload
def visit(self, node: ast.AnnAssign, parent: NodeNG) -> nodes.AnnAssign:
@overload
def visit(self, node: ast.AugAssign, parent: NodeNG) -> nodes.AugAssign:
@overload
def visit(self, node: ast.BinOp, parent: NodeNG) -> nodes.BinOp:
@overload
def visit(self, node: ast.BoolOp, parent: NodeNG) -> nodes.BoolOp:
@overload
def visit(self, node: ast.Break, parent: NodeNG) -> nodes.Break:
@overload
def visit(self, node: ast.Call, parent: NodeNG) -> nodes.Call:
@overload
def visit(self, node: ast.ClassDef, parent: NodeNG) -> nodes.ClassDef:
@overload
def visit(self, node: ast.Continue, parent: NodeNG) -> nodes.Continue:
@overload
def visit(self, node: ast.Compare, parent: NodeNG) -> nodes.Compare:
@overload
def visit(self, node: ast.comprehension, parent: NodeNG) -> nodes.Comprehension:
@overload
def visit(self, node: ast.Delete, parent: NodeNG) -> nodes.Delete:
@overload
def visit(self, node: ast.Dict, parent: NodeNG) -> nodes.Dict:
@overload
def visit(self, node: ast.DictComp, parent: NodeNG) -> nodes.DictComp:
@overload
def visit(self, node: ast.Expr, parent: NodeNG) -> nodes.Expr:
@overload
def visit(self, node: ast.Ellipsis, parent: NodeNG) -> nodes.Const:
@overload
def visit(self, node: ast.ExceptHandler, parent: NodeNG) -> nodes.ExceptHandler:
@overload
def visit(self, node: ast.ExtSlice, parent: nodes.Subscript) -> nodes.Tuple:
@overload
def visit(self, node: ast.For, parent: NodeNG) -> nodes.For:
@overload
def visit(self, node: ast.ImportFrom, parent: NodeNG) -> nodes.ImportFrom:
@overload
def visit(self, node: ast.FunctionDef, parent: NodeNG) -> nodes.FunctionDef:
@overload
def visit(self, node: ast.GeneratorExp, parent: NodeNG) -> nodes.GeneratorExp:
@overload
def visit(self, node: ast.Attribute, parent: NodeNG) -> nodes.Attribute:
@overload
def visit(self, node: ast.Global, parent: NodeNG) -> nodes.Global:
@overload
def visit(self, node: ast.If, parent: NodeNG) -> nodes.If:
@overload
def visit(self, node: ast.IfExp, parent: NodeNG) -> nodes.IfExp:
@overload
def visit(self, node: ast.Import, parent: NodeNG) -> nodes.Import:
@overload
def visit(self, node: ast.JoinedStr, parent: NodeNG) -> nodes.JoinedStr:
@overload
def visit(self, node: ast.FormattedValue, parent: NodeNG) -> nodes.FormattedValue:
@overload
def visit(self, node: ast.NamedExpr, parent: NodeNG) -> nodes.NamedExpr:
@overload
def visit(self, node: ast.Index, parent: nodes.Subscript) -> NodeNG:
@overload
def visit(self, node: ast.keyword, parent: NodeNG) -> nodes.Keyword:
@overload
def visit(self, node: ast.Lambda, parent: NodeNG) -> nodes.Lambda:
@overload
def visit(self, node: ast.List, parent: NodeNG) -> nodes.List:
@overload
def visit(self, node: ast.ListComp, parent: NodeNG) -> nodes.ListComp:
@overload
def visit(self, node: ast.Name, parent: NodeNG) -> nodes.Name | nodes.Const | nodes.AssignName | nodes.DelName:
@overload
def visit(self, node: ast.NameConstant, parent: NodeNG) -> nodes.Const:
@overload
def visit(self, node: ast.Nonlocal, parent: NodeNG) -> nodes.Nonlocal:
@overload
def visit(self, node: ast.Str, parent: NodeNG) -> nodes.Const:
@overload
def visit(self, node: ast.Bytes, parent: NodeNG) -> nodes.Const:
@overload
def visit(self, node: ast.Num, parent: NodeNG) -> nodes.Const:
@overload
def visit(self, node: ast.Constant, parent: NodeNG) -> nodes.Const:
@overload
def visit(self, node: ast.Pass, parent: NodeNG) -> nodes.Pass:
@overload
def visit(self, node: ast.Raise, parent: NodeNG) -> nodes.Raise:
@overload
def visit(self, node: ast.Return, parent: NodeNG) -> nodes.Return:
@overload
def visit(self, node: ast.Set, parent: NodeNG) -> nodes.Set:
@overload
def visit(self, node: ast.SetComp, parent: NodeNG) -> nodes.SetComp:
@overload
def visit(self, node: ast.Slice, parent: nodes.Subscript) -> nodes.Slice:
@overload
def visit(self, node: ast.Subscript, parent: NodeNG) -> nodes.Subscript:
@overload
def visit(self, node: ast.Starred, parent: NodeNG) -> nodes.Starred:
@overload
def visit(self, node: ast.Try, parent: NodeNG) -> nodes.TryExcept | nodes.TryFinally:
@overload
def visit(self, node: ast.Tuple, parent: NodeNG) -> nodes.Tuple:
@overload
def visit(self, node: ast.UnaryOp, parent: NodeNG) -> nodes.UnaryOp:
@overload
def visit(self, node: ast.While, parent: NodeNG) -> nodes.While:
@overload
def visit(self, node: ast.With, parent: NodeNG) -> nodes.With:
@overload
def visit(self, node: ast.Yield, parent: NodeNG) -> nodes.Yield:
@overload
def visit(self, node: ast.YieldFrom, parent: NodeNG) -> nodes.YieldFrom:
@overload
def visit(self, node: ast.Match, parent: NodeNG) -> nodes.Match:
@overload
def visit(self, node: ast.match_case, parent: NodeNG) -> nodes.MatchCase:
@overload
def visit(self, node: ast.MatchValue, parent: NodeNG) -> nodes.MatchValue:
@overload
def visit(self, node: ast.MatchSingleton, parent: NodeNG) -> nodes.MatchSingleton:
@overload
def visit(self, node: ast.MatchSequence, parent: NodeNG) -> nodes.MatchSequence:
@overload
def visit(self, node: ast.MatchMapping, parent: NodeNG) -> nodes.MatchMapping:
@overload
def visit(self, node: ast.MatchClass, parent: NodeNG) -> nodes.MatchClass:
@overload
def visit(self, node: ast.MatchStar, parent: NodeNG) -> nodes.MatchStar:
@overload
def visit(self, node: ast.MatchAs, parent: NodeNG) -> nodes.MatchAs:
@overload
def visit(self, node: ast.MatchOr, parent: NodeNG) -> nodes.MatchOr:
@overload
def visit(self, node: ast.pattern, parent: NodeNG) -> nodes.Pattern:
@overload
def visit(self, node: ast.AST, parent: NodeNG) -> NodeNG:
@overload
def visit(self, node: None, parent: NodeNG):
(source)

Undocumented

def visit_annassign(self, node: ast.AnnAssign, parent: NodeNG) -> nodes.AnnAssign: (source)

visit an AnnAssign node by returning a fresh instance of it

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

visit an arg node by returning a fresh AssName instance

def visit_arguments(self, node: ast.arguments, parent: NodeNG) -> nodes.Arguments: (source)

visit an Arguments node by returning a fresh instance of it

def visit_assert(self, node: ast.Assert, parent: NodeNG) -> nodes.Assert: (source)

visit a Assert node by returning a fresh instance of it

def visit_assign(self, node: ast.Assign, parent: NodeNG) -> nodes.Assign: (source)

visit a Assign node by returning a fresh instance of it

@overload
def visit_assignname(self, node: ast.AST, parent: NodeNG, node_name: str) -> nodes.AssignName:
@overload
def visit_assignname(self, node: ast.AST, parent: NodeNG, node_name: None):
(source)

visit a node and return a AssignName node

Note: Method not called by 'visit'

def visit_asyncfor(self, node: ast.AsyncFor, parent: NodeNG) -> nodes.AsyncFor: (source)

Undocumented

def visit_asyncfunctiondef(self, node: ast.AsyncFunctionDef, parent: NodeNG) -> nodes.AsyncFunctionDef: (source)

Undocumented

def visit_asyncwith(self, node: ast.AsyncWith, parent: NodeNG) -> nodes.AsyncWith: (source)

Undocumented

def visit_attribute(self, node: ast.Attribute, parent: NodeNG) -> nodes.Attribute | nodes.AssignAttr | nodes.DelAttr: (source)

visit an Attribute node by returning a fresh instance of it

def visit_augassign(self, node: ast.AugAssign, parent: NodeNG) -> nodes.AugAssign: (source)

visit a AugAssign node by returning a fresh instance of it

def visit_await(self, node: ast.Await, parent: NodeNG) -> nodes.Await: (source)

Undocumented

def visit_binop(self, node: ast.BinOp, parent: NodeNG) -> nodes.BinOp: (source)

visit a BinOp node by returning a fresh instance of it

def visit_boolop(self, node: ast.BoolOp, parent: NodeNG) -> nodes.BoolOp: (source)

visit a BoolOp node by returning a fresh instance of it

def visit_break(self, node: ast.Break, parent: NodeNG) -> nodes.Break: (source)

visit a Break node by returning a fresh instance of it

def visit_call(self, node: ast.Call, parent: NodeNG) -> nodes.Call: (source)

visit a CallFunc node by returning a fresh instance of it

def visit_classdef(self, node: ast.ClassDef, parent: NodeNG, newstyle: bool = True) -> nodes.ClassDef: (source)

visit a ClassDef node to become astroid

def visit_compare(self, node: ast.Compare, parent: NodeNG) -> nodes.Compare: (source)

visit a Compare node by returning a fresh instance of it

def visit_comprehension(self, node: ast.comprehension, parent: NodeNG) -> nodes.Comprehension: (source)

visit a Comprehension node by returning a fresh instance of it

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

visit a Constant node by returning a fresh instance of Const

def visit_continue(self, node: ast.Continue, parent: NodeNG) -> nodes.Continue: (source)

visit a Continue node by returning a fresh instance of it

def visit_decorators(self, node: ast.ClassDef | ast.FunctionDef | ast.AsyncFunctionDef, parent: NodeNG) -> nodes.Decorators | None: (source)

visit a Decorators node by returning a fresh instance of it

Note: Method not called by 'visit'

def visit_delete(self, node: ast.Delete, parent: NodeNG) -> nodes.Delete: (source)

visit a Delete node by returning a fresh instance of it

def visit_dict(self, node: ast.Dict, parent: NodeNG) -> nodes.Dict: (source)

visit a Dict node by returning a fresh instance of it

def visit_dictcomp(self, node: ast.DictComp, parent: NodeNG) -> nodes.DictComp: (source)

visit a DictComp node by returning a fresh instance of it

def visit_ellipsis(self, node: ast.Ellipsis, parent: NodeNG) -> nodes.Const: (source)

visit an Ellipsis node by returning a fresh instance of Const

def visit_excepthandler(self, node: ast.ExceptHandler, parent: NodeNG) -> nodes.ExceptHandler: (source)

visit an ExceptHandler node by returning a fresh instance of it

def visit_expr(self, node: ast.Expr, parent: NodeNG) -> nodes.Expr: (source)

visit a Expr node by returning a fresh instance of it

def visit_extslice(self, node: ast.ExtSlice, parent: nodes.Subscript) -> nodes.Tuple: (source)

visit an ExtSlice node by returning a fresh instance of Tuple

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

Undocumented

def visit_formattedvalue(self, node: ast.FormattedValue, parent: NodeNG) -> nodes.FormattedValue: (source)

Undocumented

def visit_functiondef(self, node: ast.FunctionDef, parent: NodeNG) -> nodes.FunctionDef: (source)

Undocumented

def visit_generatorexp(self, node: ast.GeneratorExp, parent: NodeNG) -> nodes.GeneratorExp: (source)

visit a GeneratorExp node by returning a fresh instance of it

def visit_global(self, node: ast.Global, parent: NodeNG) -> nodes.Global: (source)

visit a Global node to become astroid

def visit_if(self, node: ast.If, parent: NodeNG) -> nodes.If: (source)

visit an If node by returning a fresh instance of it

def visit_ifexp(self, node: ast.IfExp, parent: NodeNG) -> nodes.IfExp: (source)

visit a IfExp node by returning a fresh instance of it

def visit_import(self, node: ast.Import, parent: NodeNG) -> nodes.Import: (source)

visit a Import node by returning a fresh instance of it

def visit_importfrom(self, node: ast.ImportFrom, parent: NodeNG) -> nodes.ImportFrom: (source)

visit an ImportFrom node by returning a fresh instance of it

def visit_index(self, node: ast.Index, parent: nodes.Subscript) -> NodeNG: (source)

visit a Index node by returning a fresh instance of NodeNG

def visit_joinedstr(self, node: ast.JoinedStr, parent: NodeNG) -> nodes.JoinedStr: (source)

Undocumented

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

visit a Keyword node by returning a fresh instance of it

def visit_lambda(self, node: ast.Lambda, parent: NodeNG) -> nodes.Lambda: (source)

visit a Lambda node by returning a fresh instance of it

def visit_list(self, node: ast.List, parent: NodeNG) -> nodes.List: (source)

visit a List node by returning a fresh instance of it

def visit_listcomp(self, node: ast.ListComp, parent: NodeNG) -> nodes.ListComp: (source)

visit a ListComp node by returning a fresh instance of it

def visit_match(self, node: ast.Match, parent: NodeNG) -> nodes.Match: (source)

Undocumented

def visit_matchas(self, node: ast.MatchAs, parent: NodeNG) -> nodes.MatchAs: (source)

Undocumented

def visit_matchcase(self, node: ast.match_case, parent: NodeNG) -> nodes.MatchCase: (source)

Undocumented

def visit_matchclass(self, node: ast.MatchClass, parent: NodeNG) -> nodes.MatchClass: (source)

Undocumented

def visit_matchmapping(self, node: ast.MatchMapping, parent: NodeNG) -> nodes.MatchMapping: (source)

Undocumented

def visit_matchor(self, node: ast.MatchOr, parent: NodeNG) -> nodes.MatchOr: (source)

Undocumented

def visit_matchsequence(self, node: ast.MatchSequence, parent: NodeNG) -> nodes.MatchSequence: (source)

Undocumented

def visit_matchsingleton(self, node: ast.MatchSingleton, parent: NodeNG) -> nodes.MatchSingleton: (source)

Undocumented

def visit_matchstar(self, node: ast.MatchStar, parent: NodeNG) -> nodes.MatchStar: (source)

Undocumented

def visit_matchvalue(self, node: ast.MatchValue, parent: NodeNG) -> nodes.MatchValue: (source)

Undocumented

def visit_module(self, node: ast.Module, modname: str, modpath: str, package: bool) -> nodes.Module: (source)

visit a Module node by returning a fresh instance of it

Note: Method not called by 'visit'

def visit_name(self, node: ast.Name, parent: NodeNG) -> nodes.Name | nodes.AssignName | nodes.DelName: (source)

visit a Name node by returning a fresh instance of it

def visit_nameconstant(self, node: ast.NameConstant, parent: NodeNG) -> nodes.Const: (source)

Undocumented

def visit_namedexpr(self, node: ast.NamedExpr, parent: NodeNG) -> nodes.NamedExpr: (source)

Undocumented

def visit_nonlocal(self, node: ast.Nonlocal, parent: NodeNG) -> nodes.Nonlocal: (source)

visit a Nonlocal node and return a new instance of it

def visit_num(self, node: ast.Num, parent: NodeNG) -> nodes.Const: (source)

visit a Num node by returning a fresh instance of Const

def visit_pass(self, node: ast.Pass, parent: NodeNG) -> nodes.Pass: (source)

visit a Pass node by returning a fresh instance of it

def visit_raise(self, node: ast.Raise, parent: NodeNG) -> nodes.Raise: (source)

visit a Raise node by returning a fresh instance of it

def visit_return(self, node: ast.Return, parent: NodeNG) -> nodes.Return: (source)

visit a Return node by returning a fresh instance of it

def visit_set(self, node: ast.Set, parent: NodeNG) -> nodes.Set: (source)

visit a Set node by returning a fresh instance of it

def visit_setcomp(self, node: ast.SetComp, parent: NodeNG) -> nodes.SetComp: (source)

visit a SetComp node by returning a fresh instance of it

def visit_slice(self, node: ast.Slice, parent: nodes.Subscript) -> nodes.Slice: (source)

visit a Slice node by returning a fresh instance of it

def visit_starred(self, node: ast.Starred, parent: NodeNG) -> nodes.Starred: (source)

visit a Starred node and return a new instance of it

def visit_str(self, node: ast.Str | ast.Bytes, parent: NodeNG) -> nodes.Const: (source)

visit a String/Bytes node by returning a fresh instance of Const

def visit_subscript(self, node: ast.Subscript, parent: NodeNG) -> nodes.Subscript: (source)

visit a Subscript node by returning a fresh instance of it

def visit_try(self, node: ast.Try, parent: NodeNG) -> nodes.TryExcept | nodes.TryFinally | None: (source)

Undocumented

def visit_tryexcept(self, node: ast.Try, parent: NodeNG) -> nodes.TryExcept: (source)

visit a TryExcept node by returning a fresh instance of it

def visit_tryfinally(self, node: ast.Try, parent: NodeNG) -> nodes.TryFinally: (source)

visit a TryFinally node by returning a fresh instance of it

def visit_tuple(self, node: ast.Tuple, parent: NodeNG) -> nodes.Tuple: (source)

visit a Tuple node by returning a fresh instance of it

def visit_unaryop(self, node: ast.UnaryOp, parent: NodeNG) -> nodes.UnaryOp: (source)

visit a UnaryOp node by returning a fresh instance of it

def visit_while(self, node: ast.While, parent: NodeNG) -> nodes.While: (source)

visit a While node by returning a fresh instance of it

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

Undocumented

def visit_yield(self, node: ast.Yield, parent: NodeNG) -> NodeNG: (source)

visit a Yield node by returning a fresh instance of it

def visit_yieldfrom(self, node: ast.YieldFrom, parent: NodeNG) -> NodeNG: (source)

Undocumented

def _get_context(self, node: ast.Attribute | ast.List | ast.Name | ast.Subscript | ast.Starred | ast.Tuple) -> Context: (source)

Undocumented

def _get_doc(self, node: T_Doc) -> tuple[T_Doc, str | None]: (source)

Undocumented

def _save_assignment(self, node: nodes.AssignName | nodes.DelName): (source)

save assignment situation since node.parent is not available yet

def _visit_dict_items(self, node: ast.Dict, parent: NodeNG, newnode: nodes.Dict) -> Generator[tuple[NodeNG, NodeNG], None, None]: (source)

Undocumented

@overload
def _visit_for(self, cls: type[nodes.For], node: ast.For, parent: NodeNG) -> nodes.For:
@overload
def _visit_for(self, cls: type[nodes.AsyncFor], node: ast.AsyncFor, parent: NodeNG) -> nodes.AsyncFor:
(source)

visit a For node by returning a fresh instance of it

@overload
def _visit_functiondef(self, cls: type[nodes.FunctionDef], node: ast.FunctionDef, parent: NodeNG) -> nodes.FunctionDef:
@overload
def _visit_functiondef(self, cls: type[nodes.AsyncFunctionDef], node: ast.AsyncFunctionDef, parent: NodeNG) -> nodes.AsyncFunctionDef:
(source)

visit an FunctionDef node to become astroid

@overload
def _visit_with(self, cls: type[nodes.With], node: ast.With, parent: NodeNG) -> nodes.With:
@overload
def _visit_with(self, cls: type[nodes.AsyncWith], node: ast.AsyncWith, parent: NodeNG) -> nodes.AsyncWith:
(source)

Undocumented

_delayed_assattr: list[nodes.AssignAttr] = (source)

Undocumented

_global_names: list[dict[str, list[nodes.Global]]] = (source)

Undocumented

_import_from_nodes: list[nodes.ImportFrom] = (source)

Undocumented

_manager = (source)

Undocumented

_module = (source)

Undocumented

_parser_module = (source)

Undocumented

_visit_meths: dict[type[ast.AST], Callable[[ast.AST, NodeNG], NodeNG]] = (source)

Undocumented