record FnLowerer: 'arena + 'phase + 'function where 'arena: 'phase, 'phase: 'function {

    /// Reference to the module-level lowerer.

    low: &'function mut Lowerer 'arena 'phase,

    /// Arena for allocations owned by this function.

    arena: &'function mut alloc::Arena,

    /// Type signature of the function being lowered.

    fnType: *resolver::FnType,

    /// Number of SSA variable slots required for each block.

    localCount: u32,

    /// Function name, used as prefix for generated data symbols.

    self: &'function mut Lowerer 'arena 'phase,

    sourceOffset: u32,

    fnType: *resolver::FnType,

    qualName: *[u8],

    functionArena: &'function mut alloc::Arena,

) -> FnLowerer 'arena 'phase 'function where 'arena: 'phase, 'phase: 'function {

    let localCount = variables.len;

    let mut fnLow = FnLowerer 'arena 'phase 'function {

        low: self,

        arena: functionArena,

        fnType,

        localCount,

        fnName: qualName,

        vars: Variables 'function { items: variables, len: 0 },

        params: [FnParamBinding { var: Var(0), reg: il::Reg { n: 0 } }; resolver::MAX_FN_PARAMS],

    // Register function symbol for cross-package call resolution.

    if let sym = resolver::symbolFor(self.resolver, node) {

        registerSymbolName(&mut self.symbolNames, sym, qualName, alloc::arenaAllocator(self.arena));

    }

    let parent: 'function = &mut *self, arena = &mut *functionArena, variables = &mut variableSlots[..] where 'phase: 'function in {

        // If the function returns an aggregate or is throwing, prepend a hidden

        // return parameter. The caller allocates the buffer and passes it

        // as the first argument; the callee writes the return value into it.

        if requiresReturnParam(fnType) and not isExtern {

        throw LowerError::ExpectedFunction;

    };

    let sym = resolver::symbolFor(self.resolver, node) else throw LowerError::MissingSymbol(node);

    registerSymbolName(&mut self.symbolNames, sym, qualName, alloc::arenaAllocator(self.arena));

    let parent: 'function = &mut *self, arena = &mut *functionArena, variables = &mut variableSlots[..] where 'phase: 'function in {

        if requiresReturnParam(fnType) {

            set fnLow.returnReg = nextReg(&mut fnLow);

        }

        let lowParams = try lowerParams(&mut fnLow, *fnType, sig.params, receiverName);

        let func = try! alloc::alloc(&mut *fnLow.arena, @sizeOf(il::Fn), @alignOf(il::Fn)) as *mut il::Fn;

    }

    return buf;

}

/// Generate a unique label by appending the global counter to the base.

    let idx = self.labelCounter;

    set self.labelCounter += 1;

}

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

// Data Section Construction //

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

/// Create a new basic block with the given label base.

///

/// The block is initially unsealed (predecessors may be added later) and empty.

/// Returns a [`BlockId`] that can be used for jumps and branches. The block must

/// be switched to via [`switchToBlock`] before instructions can be emitted.

    let label = try nextLabel(self, labelBase);

    let varCount = self.localCount;

    let depth = self.loopDepth;

    return appendBlock(&mut self.blockData, label, varCount, depth, allocator);

}

/// Append a complete unsealed block with initialized variable slots.

    return id;

}

/// Create a new block with a single parameter.

    self: &mut FnLowerer 'arena 'phase 'function,

    labelBase: *[u8],

    param: il::Param

) -> BlockId throws (LowerError) where 'arena: 'phase, 'phase: 'function {

    let block = try createBlock(self, labelBase);

    self.blockData[*block].params.append(param, allocator);

    return block;

}

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

// Instruction Emission //

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

/// Emit an instruction to the current block.

    recordInstruction(self, &instr, allocator);

}

/// Append an instruction and its enabled source location to the current block.

fn recordInstruction 'arena 'phase 'function (

// Control Flow Edge Management //

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

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

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

    insertPredecessor(&mut self.blockData[..], target, pred, allocator);

}

/// Insert one distinct predecessor into an unsealed block's owned list.

fn insertPredecessor(blocks: &mut [BlockData], target: BlockId, pred: BlockId, allocator: alloc::Allocator) {

    }

    return self.loopStack[self.loopDepth - 1];

}

/// Get or lazily create the continue target block for the current loop.

    let ctx = currentLoop(self) else {

        throw LowerError::OutsideOfLoop;

    };

    if let block = ctx.continueTarget {

        return block;

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

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

            return val;

        }

        case VarSource::Merge => {

        },

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

    }

}

        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.

    return sameVal;

}

/// Patch a single terminator argument for a specific edge. This is used during

/// SSA construction to pass variable values along control flow edges.

    self: &mut FnLowerer 'arena 'phase 'function,

    from: BlockId,         // The predecessor block containing the terminator to patch.

    target: u32,           // The index of the target block we're passing the value to.

    paramIdx: u32,         // The index of the block parameter to set.

    val: il::Val           // The value to pass as the argument.

) where 'arena: 'phase, 'phase: 'function {

    // Get mutable block data by block id.

    let data = &mut self.blockData[*from];

    let ix = data.instrs.len - 1; // The terminator is always the last instruction.

    patchEdgeArgs(&mut data.instrs[ix], target, paramIdx, val, allocator);

}