/// Seal a block, indicating all predecessor edges are now known.

///

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

    let paramCount = markBlockSealed(&mut self.blockData[*block]) else return;

    // Complete each parameter that was created before sealing.

    for paramIdx in 0..paramCount {

        let varId = self.blockData[*block].paramVars[paramIdx];

    set block.sealState = Sealed::Yes;

    return paramCount;

}

/// Seal a block and switch to it.

    try sealBlock(self, block);

    switchToBlock(self, block);

}

/// Get the number of predecessors for a block.

    set self.blockData[*block].vars[*v] = val;

}

/// Use (read) the current value of a variable in the current block.

/// May insert block parameters if the value must come from predecessors.

    return try useVarInBlock(self, currentBlock(self), v);

}

/// Resolve which SSA definition of a variable reaches a use point in a given block.

///

/// Given a variable and a block where it's used, this function finds the

/// correct [`il::Val`] that holds the variable's value at that program point.

/// When control flow merges from multiple predecessors with different

/// definitions, it creates a block parameter to unify them.

    assert *v < self.vars.len;

    match varSource(&self.blockData[..], block, self.entryBlock, v) {

        case VarSource::Value(val) => return val,

        case VarSource::Predecessor(pred) => {

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

            set self.blockData[*block].vars[*v] = val; // Cache.

            return val;

        }

        case VarSource::Invalid => throw LowerError::InvalidUse,

    }

}

/// Select the cached, predecessor, or merge source while borrowing block state.

///     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 count = predecessorCount(&self.blockData[..], 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.

        let pred = BlockId(self.blockData[*block].preds[index]);

        // 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";

    }

}

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

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

    let count = predecessorCount(&self.blockData[..], block);

    // Get the block parameter register.

    let paramReg = self.blockData[*block].vars[*v];

    // Check if all predecessors provide the same value.

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