///

/// The key invariants:

///

/// - A block is "open" if it has no terminator; instructions can be added.

/// - A block is "sealed" when all predecessor edges are known.

///

/// This differs from the final [`il::Block`] which is immutable and fully formed.

record BlockData: Copy {

    /// Block label for debugging and IL printing.

    label: *[u8],

    /// Block parameters for merging values at control flow joins. These

    /// receive values from predecessor edges when control flow merges.

    params: *mut [il::Param],

    paramVars: *mut [u32],

    /// Instructions accumulated so far. The last instruction should eventually

    /// be a terminator.

    instrs: *mut [il::Instr],

    /// Debug source locations, one per instruction. Only populated when

}

/// Block sealing state for SSA construction.

///

/// A block is "unsealed" while its predecessors are still being discovered.

union Sealed: Copy {

    /// Block is unsealed; predecessors may still be added.

    /// Block is sealed; all predecessors are known.

    Yes,

}

///////////////////////////////////

        paramVars: &mut [],

        instrs: &mut [],

        locs: &mut [],

        preds: &mut [],

        vars,

        loopDepth: self.loopDepth,

    }, self.allocator);

    return id;

}

/// Sealing enables SSA construction to resolve variable uses by looking up

/// values from predecessors and inserting block parameters as needed. It

/// does not prevent instructions from being added to the block.

fn sealBlock(self: *mut FnLowerer, block: BlockId) throws (LowerError) {

    let blk = getBlockMut(self, block);

        return; // Already sealed.

    };

    set blk.sealState = Sealed::Yes;

    }

}

/// Seal a block and switch to it.

fn switchToAndSeal(self: *mut FnLowerer, block: BlockId) throws (LowerError) {

//

// 2. **Sealed block with single predecessor**: If all incoming edges are known

//    and there's exactly one predecessor, recurse to that predecessor. No merge

//    is needed since there's only one path. The result is cached.

//

//

// Consider this code:

//

//     let mut x = 1;

//     if cond {

}

/// Create a block parameter to merge a variable's value from multiple

/// control flow paths.

///

///

///     @then

///       jmp @end(1);            // x = 1

///     @else

///       jmp @end(2);            // x = 2

///     @end(w32 %1)              // x = %1, merged from predecessors

///       ret %1;

///

fn createBlockParam(self: *mut FnLowerer, block: BlockId, v: Var) -> il::Val throws (LowerError) {

    // Entry block must not have block parameters.

    assert block <> self.entryBlock, "createBlockParam: entry block must not have block parameters";

    // Allocate a register to hold the merged value.

    let reg = nextReg(self);

    let type = getVar(self, v).type;

    // Create block parameter and add it to the block.

    let param = il::Param { value: reg, type };

    let blk = getBlockMut(self, block);

    blk.params.append(param, self.allocator);

    blk.paramVars.append(*v, self.allocator); // Associate variable with parameter.

    // Record that this variable's value in this block is now the parameter register.

    // This must happen before the predecessor loop to handle self-referential loops.

    set blk.vars[*v] = il::Val::Reg(reg);

    }

    return il::Val::Reg(reg);

}

///

/// This is the block-parameter equivalent of adding operands to a phi-function in

/// traditional SSA. Where a phi-function merges values at the join point:

///

///     x3 = phi(x1, x2)

///

/// This representation avoids the need for phi nodes to reference their

/// predecessor blocks explicitly, since the control flow edges already encode

/// that information.

    let blk = getBlock(self, block);

    // For each predecessor, recursively look up the variable's reaching definition

    // in that block, then patch the predecessor's terminator to pass that value

    // as an argument to this block's parameter.

    for predId in blk.preds {

        let pred = BlockId(predId);