IfBlockStatement

Abstract representation of the if/elif/else statement block. For example, if there is a code block like: if condition1: block1 elif condition2: block2 else: block3 This class represents the entire block, including the conditions and nested code blocks. Attributes: condition: The condition expression for the if block. None if the block is an else block. consequence_block: The code block that is executed if the condition is True.

Inherits from

Statement, Expression, Editable

Properties

---

alternative_blocks

A list of alternative if/elif/else blocks that are executed if the condition is False.

def alternative_blocks(self) -> list[TIfBlockStatement]:
    ...

extended

Returns a SymbolGroup of all extended nodes. This allows a common edit interface for all of extended nodes.

def extended(self) -> SymbolGroup:
    ...

extended_source

Text representation of all its extended nodes

def extended_source(self) -> str:
    ...

file

The file object that this Editable instance belongs to

def file(self) -> File:
    ...

filepath

The file path of the file that this Editable instance belongs to

def filepath(self) -> str:
    ...

function_calls

Returns all contained function calls. Useful for renaming function invocations etc.

def function_calls(self) -> list[FunctionCall]:
    ...

index

The 0-based index of the statement in the parent code block.

def index(self) -> int:
    ...

is_elif_statement

Returns True if the current block is an elif block. False otherwise.

def is_elif_statement(self) -> bool:
    ...

is_else_statement

Returns True if the current block is an else block. False otherwise.

def is_else_statement(self) -> bool:
    ...

is_if_statement

Returns True if the current block is an if block. False otherwise.

def is_if_statement(self) -> bool:
    ...

nested_code_blocks

Returns all nested CodeBlocks within the statement.

def nested_code_blocks(self) -> list[TCodeBlock]:
    ...

nested_statements

Returns a list of collections of nested statements within nested blocks in the given statement.

Example:

Given an if block statement:
if (condition) {
statement1;
statement2;
} elif (condition2) {
statement3;
}
Returns a list of collections for each nested block:
[ MultiLineCollection[statement1, statement2], MultiLineCollection[statement3] ]

def nested_statements(self: Statement[TParent, TBlock]) -> list[MultiLineCollection[Statement[TParent, TBlock], Statement[TParent, TBlock]]]:
    ...

resolved_value

If the expression is a resolvable value, returns the last assigned expression value. Else, returns itself.

Example: a = 1 b = a foo(b)

If we call resolve_value on b, it returns 1.

def resolved_value(self) -> Expression | list[Expression]:
    ...

source

Text representation of the Editable instance

def source(self) -> str:
    ...

variable_usages

Returns Editables for all TreeSitter node instances of variable usages. (Excludes: property identifiers and argument keywords) This is useful for renaming variables locally and analyzing variable usages.

def variable_usages(self) -> list[Editable]:
    ...

Attributes

---

condition

The condition expression for the if block. None if the block is an else block.

condition: Expression[Self] | None

consequence_block

The code block that is executed if the condition is True.

consequence_block: TCodeBlock

Methods

---

commit

Commit just this node

def commit(self) -> None:
    ...

edit

Replace the source of this Editable with new_src. When fix_indentation is True, the indentation of new_src will be adjusted to match the current text’s indentation.

def edit(self, new_src: str, fix_indentation: bool = False, priority: int = 0, dedupe: bool = True) -> None:
    ...

find

Returns a list of all substring match in strings_to_match, similar to python’s str.find(..)

Args: exact: Only match individual nodes which exactly match the query

def find(self, strings_to_match: list[str] | str, *, exact: bool = False) -> list[Editable]:
    ...

find_string_literals

Returns a list of all editable substrings within string literals that match strings_to_match

def find_string_literals(self, strings_to_match: list[str], fuzzy_match: bool = False) -> list[Editable]:
    ...

flag

Adds a comment so the developer can see this Editable

def flag(self) -> None:
    ...

get_elif_statements

Returns all elif blocks within the if block.

def get_elif_statements(self) -> list[TIfBlockStatement]:
    ...

get_else_statement

Returns the else block within the if block if it exists. Otherwise, returns None.

def get_else_statement(self) -> TIfBlockStatement | None:
    ...

get_variable_usages

Returns Editables for all TreeSitter nodes corresponding to instances of variable usage that matches the given variable name. (Excludes: property identifiers and argument keywords) fuzzy_match allows for partial matching of variable names and effectively does var_name in usage.name

def get_variable_usages(self, var_name: str, fuzzy_match: bool = False) -> list[Editable]:
    ...

insert_after

Inserts new_src after this node

def insert_after(self, new_src: str, fix_indentation: bool = False, newline: bool = True, priority: int = 0, dedupe: bool = True) -> None:
    ...

insert_before

Inserts new_src before this node

def insert_before(self, new_src: str, fix_indentation: bool = False, newline: bool = True, priority: int = 0, dedupe: bool = True) -> None:
    ...

reduce_condition

Simplify the condition expression given a new boolean if condition value. For example, if condition1 is reduced to True in the given if block: ''' if condition1: block1 elif condition2: block3 ''' then the resulting if block will be ''' block1 if condition2: block3 '''

def reduce_condition(self, bool_condition: bool) -> None:
    ...

remove

Deletes this Node, and optionally its related extended nodes (e.g. decorators, comments, etc.)

def remove(self, delete_formatting: bool = True, priority: int = 0, dedupe: bool = True) -> None:
    ...

replace

Search and replace an instance of substring within this node’s source. Similar to python’s string.replace(..) Throws ValueError if there are more than one occurrence of substring in this node’s source.

Arguments: old: the occurrences of this string to replace new: the string to replace with count: the max number of occurrences to replace. Default value: -1 (replace all) is_regex: whether old is a regex pattern. Default value: False

Returns: The total count of old occurrences replaced.

def replace(self, old: str, new: str, count: int = -1, is_regex: bool = False, priority: int = 0) -> int:
    ...

search

Returns a list of all regex match of regex_pattern, similar to python’s re.search(…)

When include_strings is False, the search will exclude the contents of string literals from the search. When include_comments is False, the search will exclude the contents of comments from the search.

def search(self, regex_pattern: str, include_strings: bool = True, include_comments: bool = True) -> list[Editable]:
    ...