Function fix_function_overloads

mypy/nativeparse.py:1805–1950

Merge consecutive function overloads into OverloadedFuncDef nodes. Also handles conditional overloads (overloads inside if statements).

(state: State, stmts: list[Statement])

def fix_function_overloads(state: State, stmts: list[Statement]) -> list[Statement]:
    """Merge consecutive function overloads into OverloadedFuncDef nodes.

    Also handles conditional overloads (overloads inside if statements).
    """
    ret: list[Statement] = []
    current_overload: list[OverloadPart] = []
    current_overload_name: str | None = None
    last_unconditional_func_def: str | None = None
    last_if_stmt: IfStmt | None = None
    last_if_overload: Decorator | FuncDef | OverloadedFuncDef | None = None
    last_if_stmt_overload_name: str | None = None
    last_if_unknown_truth_value: IfStmt | None = None
    skipped_if_stmts: list[IfStmt] = []
    for stmt in stmts:
        if_overload_name: str | None = None
        if_block_with_overload: Block | None = None
        if_unknown_truth_value: IfStmt | None = None
        if isinstance(stmt, IfStmt):
            # Check IfStmt block to determine if function overloads can be merged
            if_overload_name = check_ifstmt_for_overloads(stmt, current_overload_name)
            if if_overload_name is not None:
                if_block_with_overload, if_unknown_truth_value = (
                    get_executable_if_block_with_overloads(stmt, state.options)
                )

        if (
            current_overload_name is not None
            and isinstance(stmt, (Decorator, FuncDef))
            and stmt.name == current_overload_name
        ):
            if last_if_stmt is not None:
                skipped_if_stmts.append(last_if_stmt)
            if last_if_overload is not None:
                # Last stmt was an IfStmt with same overload name
                # Add overloads to current_overload
                if isinstance(last_if_overload, OverloadedFuncDef):
                    current_overload.extend(last_if_overload.items)
                else:
                    current_overload.append(last_if_overload)
                last_if_stmt, last_if_overload = None, None
            if last_if_unknown_truth_value:
                fail_merge_overload(state, last_if_unknown_truth_value)
                last_if_unknown_truth_value = None
            current_overload.append(stmt)
            if isinstance(stmt, FuncDef):
                # This is, strictly speaking, wrong: there might be a decorated
                # implementation. However, it only affects the error message we show:
                # ideally it's "already defined", but "implementation must come last"
                # is also reasonable.
                # TODO: can we get rid of this completely and just always emit
                # "implementation must come last" instead?
                last_unconditional_func_def = stmt.name
        elif (
            current_overload_name is not None
            and isinstance(stmt, IfStmt)
            and if_overload_name == current_overload_name
            and last_unconditional_func_def != current_overload_name