Function propagate_line_numbers

crates/codegen/src/ir.rs:2790–2835

(blocks: &mut [Block], predecessors: &[u32])

}

fn propagate_line_numbers(blocks: &mut [Block], predecessors: &[u32]) {
    let mut current = BlockIdx(0);
    while current != BlockIdx::NULL {
        let last = blocks[current.idx()].instructions.last().copied();
        if let Some(last) = last {
            let (next_block, has_fallthrough) = {
                let block = &blocks[current.idx()];
                (block.next, block_has_fallthrough(block))
            };

            {
                let block = &mut blocks[current.idx()];
                let mut prev_location = None;
                for instr in &mut block.instructions {
                    if let Some((location, end_location)) = prev_location {
                        maybe_propagate_location(instr, location, end_location);
                    }
                    prev_location = Some((instr.location, instr.end_location));
                }
            }

            if has_fallthrough {
                let target = next_nonempty_block(blocks, next_block);
                if target != BlockIdx::NULL && predecessors[target.idx()] == 1 {
                    propagate_locations_in_block(
                        &mut blocks[target.idx()],
                        last.location,
                        last.end_location,
                    );
                }
            }

            if is_jump_instruction(&last) {
                let target = next_nonempty_block(blocks, last.target);
                if target != BlockIdx::NULL && predecessors[target.idx()] == 1 {
                    propagate_locations_in_block(
                        &mut blocks[target.idx()],
                        last.location,
                        last.end_location,
                    );
                }
            }
        }
        current = blocks[current.idx()].next;
    }
}

fn resolve_line_numbers(blocks: &mut Vec<Block>) {
    let mut predecessors = compute_predecessors(blocks);