The unconditional jump instruction JUMP_BACKWARD_NO_INTERRUPT (introduced in Python 3.11) is not handled in get_block_successors. It falls through to the default next_offset handling, which is incorrect because it is an unconditional jump. This will cause the CFG to omit the backward edge, preventing topological_sort from detecting loops and leading to silent compilation of loops into incorrect linear code or runtime errors.

Additionally, repeatedly sorting and calling .index() on instructions_by_offset inside get_block_successors is inefficient ($O(N^2)$). We can optimize this by precomputing next_offsets once and passing it.

Note: Since this modifies code generation logic, please manually verify the diffs of the generated output against established golden files to ensure that changes are deterministic and do not introduce unintended regressions.

def get_block_successors(
    block: BasicBlock, next_offsets: dict[int, int]
) -> list[int]:
    if not block.instructions:
        return []
    last_inst = block.instructions[-1]
    opname = last_inst.opname
    offset = last_inst.offset

    next_offset = next_offsets.get(offset)

    if opname in ("RETURN_VALUE", "RETURN_CONST"):
        return []

    if opname in ("JUMP_FORWARD", "JUMP_ABSOLUTE", "JUMP_BACKWARD", "JUMP_BACKWARD_NO_INTERRUPT"):
        return [last_inst.argval]

    if "JUMP" in opname and ("IF" in opname or "OR_POP" in opname):
        successors = [last_inst.argval]
        if next_offset is not None:
            successors.append(next_offset)
        return successors

    if next_offset is not None:
        return [next_offset]
    return []

Optimize build_cfg by precomputing next_offsets in $O(N)$ time and passing it to get_block_successors to avoid redundant sorting and lookup overhead.

Note: Since this modifies code generation logic, please manually verify the diffs of the generated output against established golden files to ensure that changes are deterministic and do not introduce unintended regressions.

def build_cfg(instructions: list[dis.Instruction]) -> dict[int, BasicBlock]:
    starts = sorted(list(get_block_starts(instructions)))
    next_offsets = {inst.offset: next_inst.offset for inst, next_inst in zip(instructions, instructions[1:])}

    blocks: dict[int, BasicBlock] = {}
    for i, start in enumerate(starts):
        end = starts[i + 1] if i + 1 < len(starts) else None
        block_insts = [
            inst
            for inst in instructions
            if start <= inst.offset and (end is None or inst.offset < end)
        ]
        blocks[start] = BasicBlock(start_offset=start, instructions=block_insts)

    for block in blocks.values():
        successors = get_block_successors(block, next_offsets)
        block.successors = successors
        for succ in successors:
            blocks[succ].predecessors.append(block.start_offset)

    return blocks

Precompute next_offsets once at the beginning of _compile_bytecode_to_py_expr so it can be reused across the function to avoid rebuilding and sorting instructions_by_offset inside loops.

Note: Since this modifies code generation logic, please manually verify the diffs of the generated output against established golden files to ensure that changes are deterministic and do not introduce unintended regressions.

Avoid rebuilding and sorting instructions_by_offset inside the instruction loop by using the precomputed next_offsets dictionary.

Note: Since this modifies code generation logic, please manually verify the diffs of the generated output against established golden files to ensure that changes are deterministic and do not introduce unintended regressions.

Avoid rebuilding and sorting instructions_by_offset at the end of the block loop by using the precomputed next_offsets dictionary.

Note: Since this modifies code generation logic, please manually verify the diffs of the generated output against established golden files to ensure that changes are deterministic and do not introduce unintended regressions.

STORE_FAST is already fully handled on line 308. Because of the if/elif structure, the block on line 517 is dead code for STORE_FAST. We should simplify this block to only handle POP_TOP.

Note: Since this modifies code generation logic, please manually verify the diffs of the generated output against established golden files to ensure that changes are deterministic and do not introduce unintended regressions.

The error message for stack underflow during a function call is hardcoded to "Stack has < 2 elements". This is misleading because the function call might expect a different number of arguments (num_args). Let's make it dynamic.

Note: Since this modifies code generation logic, please manually verify the diffs of the generated output against established golden files to ensure that changes are deterministic and do not introduce unintended regressions.