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

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

/// - Sealing resolves the predecessor arguments for block parameters.

///

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

    /// 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: *unsafe mut [il::Param],

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

    /// debug info is enabled.

    locs: *unsafe mut [il::SrcLoc],

    /// Predecessor block ids. Used for SSA construction to propagate values

    /// from predecessors when a variable is used before being defined locally.

    /// The current SSA value of each variable in this block. Indexed by variable

    /// id. A `nil` means the variable wasn't assigned in this block. Updated by

    /// [`defVar`], queried by [`useVarInBlock`].

    vars: *unsafe mut [?il::Val],

    /// Sealing state. Once sealed, all predecessors are known and we can resolve

unsafe fn switchToAndSeal 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, block: BlockId) throws (LowerError) where 'arena: 'phase, 'phase: 'function {

    try sealBlock(self, block);

    switchToBlock(self, block);

}

}

/// Get mutable block data by block id.

unsafe fn getBlockMut 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, block: BlockId) -> *unsafe mut BlockData where 'arena: 'phase, 'phase: 'function {

    return &mut self.blockData[*block];

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

/// Add a predecessor edge from `pred` to `target`.

/// Must be called before the target block is sealed. Duplicates are ignored.

unsafe fn addPredecessor 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, target: BlockId, pred: BlockId) where 'arena: 'phase, 'phase: 'function {

    let preds = &mut blk.preds;

    for i in 0..preds.len {

        if preds[i] == *pred { // Avoid duplicate predecessor entries.

            return;

        }

    }

}

/// Finalize all blocks and return the block array.

unsafe fn finalizeBlocks 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function) -> *unsafe [il::Block] throws (LowerError) where 'arena: 'phase, 'phase: 'function {

    let mut blocks: *mut [il::Block] = &mut [];

///

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

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

/// that information.

unsafe fn resolveBlockArgs 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, block: BlockId, v: Var, paramIdx: u32) throws (LowerError) where 'arena: 'phase, 'phase: 'function {

    // 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.

        // This may recursively trigger more block arg resolution if the

        // predecessor also needs to look up the variable from its predecessors.

        let val = try useVarInBlock(self, pred, v);

        assert val <> il::Val::Undef, "createBlockParam: predecessor provides undef value for block parameter";

        patchTerminatorArg(self, pred, *block, paramIdx, val);

}

/// Check if a block parameter is trivial, i.e. all predecessors provide

/// the same value. Returns the trivial value if so.

unsafe fn getTrivialPhiVal 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, block: BlockId, v: Var) -> ?il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {

    // Get the block parameter register.

    // Check if all predecessors provide the same value.

    let mut sameVal: ?il::Val = nil;

        let val = try useVarInBlock(self, pred, v);

        // Check if this is a self-reference.

        // This happens in cycles where the loop back-edge passes the phi to

        // itself. We skip self-references when checking for trivial phis.

    exitLoop(self);

    // Only seal end block if it's actually reachable (ie. has predecessors).

    // If the loop has no breaks and only exits via return, the end block

    // remains unreachable and isn't added to the CFG.

        try switchToAndSeal(self, endBlock);

    }

}

/// Lower a while loop: `while <cond> { <body> }`.