astroid.rebuilder.TreeRebuilder

class documentation

class TreeRebuilder: (source)

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_trystar Undocumented
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 _fix_doc_node_position Fix start and end position of doc nodes for Python < 3.8.
Method _get_context Undocumented
Method _get_doc Return the doc ast node.
Method _get_position_info Return position information for ClassDef and FunctionDef nodes.
Method _reset_end_lineno Reset end_lineno and end_col_offset attributes for PyPy 3.8.
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 _data 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, data: str|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.ExceptHandler, parent: NodeNG) -> nodes.ExceptHandler:
@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.ExtSlice, parent: nodes.Subscript) -> nodes.Tuple:
@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.Nonlocal, parent: NodeNG) -> nodes.Nonlocal:
@overload
def visit(self, node: ast.Ellipsis, parent: NodeNG) -> nodes.Const:
@overload
def visit(self, node: ast.NameConstant, parent: NodeNG) -> nodes.Const:
@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_trystar(self, node: ast.TryStar, parent: NodeNG) -> nodes.TryStar: (source)

Undocumented

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 _fix_doc_node_position(self, node: NodesWithDocsType): (source)

Fix start and end position of doc nodes for Python < 3.8.

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, (ast.Constant|ast.Str)|None]: (source)

Return the doc ast node.

def _get_position_info(self, node: (ast.ClassDef|ast.FunctionDef)|ast.AsyncFunctionDef, parent: (nodes.ClassDef|nodes.FunctionDef)|nodes.AsyncFunctionDef) -> Position|None: (source)

Return position information for ClassDef and FunctionDef nodes. In contrast to AST positions, these only include the actual keyword(s) and the class / function name. >>> @decorator >>> async def some_func(var: int) -> None: >>> ^^^^^^^^^^^^^^^^^^^

def _reset_end_lineno(self, newnode: nodes.NodeNG): (source)

Reset end_lineno and end_col_offset attributes for PyPy 3.8. For some nodes, these are either set to -1 or only partially assigned. To keep consistency across astroid and pylint, reset all. This has been fixed in PyPy 3.9. For reference, an (incomplete) list of nodes with issues: - ClassDef - For - FunctionDef - While - Call - If - Decorators - TryExcept - With - TryFinally - Assign

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

_data = (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