Struct BasicBlock 

pub struct BasicBlock<'a> {
    pub instructions: Vec<Instruction<'a>>,
}

Represents a basic block within a function.

A basic block is a sequence of instructions that execute sequentially and end with a terminator instruction (branch, jump, or return). This structure enables control flow analysis and optimization.

Invariants

• The last instruction MUST be a terminator (Br, Jmp, or Ret)
• Instructions within a block execute in order
• Control flow only changes at block boundaries

Examples

use lamina::ir::{IRBuilder, Type, PrimitiveType, BinaryOp};
use lamina::ir::builder::{var, i32};

let mut builder = IRBuilder::new();
builder
    .function("example", Type::Void)
    .binary(BinaryOp::Add, "sum", PrimitiveType::I32, i32(10), i32(20))
    .print(var("sum"))
    .ret_void();

let module = builder.build();
let func = &module.functions["example"];
let entry_block = &func.basic_blocks["entry"];
// entry_block.instructions contains: [Binary, Print, Ret]

Fields

instructions: Vec<Instruction<'a>>

Instructions in this block (must end with a terminator)

Trait Implementations

impl<'a> Clone for BasicBlock<'a>

fn clone(&self) -> BasicBlock<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for BasicBlock<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for BasicBlock<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> PartialEq for BasicBlock<'a>

fn eq(&self, other: &BasicBlock<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> StructuralPartialEq for BasicBlock<'a>