/// When true, the SSA value is a pointer to a stack slot and reads/writes

    /// must go through memory instead of using the cached SSA value directly.

    addressTaken: bool,

}

/// Links a function parameter to its corresponding variable for the entry block.

/// After creating the entry block, we iterate through these to define initial values.

record FnParamBinding: Copy {

    /// The variable that receives this parameter's value.

    var: Var,

    // ~ SSA variable tracking ~ //

    /// Metadata (name, type, mutability) for each variable. Indexed by variable

    /// id. Doesn't change after declaration. For the SSA value of a variable in

    /// a specific block, see [`BlockData::vars`].

    /// Parameter-to-variable bindings, initialized in the entry block.

    params: [FnParamBinding; resolver::MAX_FN_PARAMS],

    /// Number of initialized parameter bindings.

    paramsLen: u32,

    set self.pkgName = pkgName;

    set self.currentMod = nil;

    set self.packageDataStart = self.data.len;

}

/// Create a new function lowerer for a given function type and name.

unsafe fn fnLowerer 'arena 'phase 'function (

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

    node: *ast::Node,

    fnType: *resolver::FnType,

    qualName: *[u8],

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

    let localCount = resolver::nodeData(self.resolver, node).localCount;

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

        low: self,

        arena: functionArena,

        fnType,

        localCount,

        fnName: qualName,

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

        paramsLen: 0,

        blockData: &mut [],

        entryBlock: nil,

        currentBlock: nil,

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

    if let sym = data.sym {

        registerSymbolName(self, sym, qualName);

    }

        // 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 = data.sym else throw LowerError::MissingSymbol(node);

    registerSymbolName(self, sym, qualName);

        if requiresReturnParam(fnType) {

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

        }

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

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

    type: il::Type,

    mutable: bool,

    val: il::Val

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

    let id = self.vars.len;

    let v = Var(id);

    if self.currentBlock <> nil {

        defVar(self, v, val);

    }

    return v;

    return try createBlockParam(self, block, v);

}

/// Look up a variable by name in the current scope.

/// Searches from most recently declared to first, enabling shadowing.

    while id > 0 {

        set id -= 1;

            // Names are interned strings, so pointer comparison suffices.

            if varName == name {

                return Var(id);

            }

        }

    }

    return nil;

}

/// Look up a local variable bound to an identifier node.

    let case ast::NodeValue::Ident(name) = node.value else {

        return nil;

    };

}

/// Save current lexical variable scope depth.

}

/// Restore lexical variable scope depth.

}

/// Get the metadata for a variable.

}

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

/// control flow paths.

///

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

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

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

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

    let blk = getBlockMut(self, block);

    let paramIdx = blk.paramVars.len;

    let firstArm = try createBlock(self, "arm");

    try emitJmp(self, firstArm);

    try switchToAndSeal(self, firstArm);

    for prongNode, i in prongs {

        let case ast::NodeValue::MatchProng(prong) = prongNode.value

            else panic "lowerMatch: expected match prong";

        let isLastArm = i + 1 == prongs.len;

        let hasGuard = prong.guard <> nil;

        }

        // Lower prong body and jump to merge if unterminated.

        try switchToAndSeal(self, bodyBlock);

        try lowerNode(self, prong.body);

        try emitMergeIfUnterminated(self, &mut mergeBlock);

        // Switch to next arm, unless last arm without guard.

        if not isLastArm or hasGuard {

            try switchToAndSeal(self, nextArm);

            if isLastArm {

    }

}

/// Lower an `if let` statement.

unsafe fn lowerIfLet 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, cond: ast::IfLet) throws (LowerError) where 'arena: 'phase, 'phase: 'function {

    let subject = try lowerMatchSubject(self, cond.pattern.scrutinee);

    let mut thenBlock: BlockId = undefined;

    if cond.pattern.guard == nil {

        set thenBlock = try createBlock(self, "then");

    }

    try lowerNode(self, cond.thenBranch);

    try emitMergeIfUnterminated(self, &mut mergeBlock);

    // Pattern bindings are visible only in the success branch. Restore the

    // outer variable scope before lowering `else`, where a same-named outer

    // variable may be referenced.

    // Lower else branch.

    try switchToAndSeal(self, elseBlock);

    if let elseBranch = cond.elseBranch {

        try lowerNode(self, elseBranch);

        "success",

        elseBlock,

    );

    let mut bindingVar: ?Var = nil;

    if let case ast::PatternKind::Binding = letElse.pattern.kind {

    }

    let mergeBlock = try createBlock(self, "merge");

    try emitJmp(self, mergeBlock);

    try switchToAndSeal(self, elseBlock);

    try switchToAndSeal(self, mergeBlock);

}

/// Lower a `while let` loop as a match-driven loop.

unsafe fn lowerWhileLet 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, w: ast::WhileLet) throws (LowerError) where 'arena: 'phase, 'phase: 'function {

    // Create control flow blocks: loop header, body (created lazily when

    // there's a guard), and exit.

    let whileBlock = try createBlock(self, "while");

    let mut bodyBlock: BlockId = undefined;

    if w.pattern.guard == nil {

    try lowerBlock(self, w.body);

    try emitJmpAndSeal(self, whileBlock);

    exitLoop(self);

    try switchToAndSeal(self, endBlock);

}

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

// Node Lowering //

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

    if self.low.options.debug {

        set self.srcLoc.offset = node.span.offset;

    }

    match node.value {

        case ast::NodeValue::RegionBlock { bindings, body, .. } => {

            let values = try allocVals(self, bindings.len);

            for bindingNode, i in bindings {

                let case ast::NodeValue::RegionBinding(binding) = bindingNode.value

                    else throw LowerError::ExpectedIdentifier;

                set values[i] = try lowerExpr(self, binding.value);

                if blockHasTerminator(self) {

                    return;

                }

            }

            for bindingNode, i in bindings {

                let case ast::NodeValue::RegionBinding(binding) = bindingNode.value

                    else throw LowerError::ExpectedIdentifier;

                try bindLetValue(self, bindingNode, ast::borrowBinding(binding), values[i]);

            }

            try lowerBlock(self, body);

        }

        case ast::NodeValue::Block(_) => {

            try lowerBlock(self, node);

        }

        case ast::NodeValue::Return { value } => {

/// Lower a code block.

unsafe fn lowerBlock 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node) throws (LowerError) where 'arena: 'phase, 'phase: 'function {

    let case ast::NodeValue::Block(blk) = node.value else {

        throw LowerError::ExpectedBlock(node);

    };

    for stmt in blk.statements {

        try lowerNode(self, stmt);

        // If the statement diverges, further statements are unreachable.

        if blockHasTerminator(self) {

            return;

        }

    }

}

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

// Record and Aggregate Type Helpers //

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

        };

        return il::Val::Reg(emitDataAddr(self, sym));

    }

    // Handle variable address: `&x`

    if let case ast::NodeValue::Ident(_) = addr.target.value {

            let val = try useVar(self, v);

            let typ = try typeOf(self, addr.target);

            // For aggregates, the value is already a pointer.

            if isAggregateType(typ) {

                return val;

            }

            // For scalars, if we've already materialized a stack slot for this

            // variable, the SSA value is that slot pointer.

                // Already address-taken; return existing stack pointer.

                return val;

            }

            // Materialize a stack slot using the declaration's resolved

            // layout so `align(N)` on locals is honored.

            let layout = resolver::getLayout(self.low.resolver, addr.target, typ);

            let slot = emitReserveLayout(self, layout);

            try emitStore(self, slot, 0, typ, val);

            let stackVal = il::Val::Reg(slot);

            defVar(self, v, stackVal);

            return stackVal;

        }

        // Fall back to symbol lookup for constants/statics.

                let layout = resolver::getLayout(self.low.resolver, node, typ);

                let slot = emitReserveLayout(self, layout);

                try emitStore(self, slot, 0, typ, varVal);

                let v = newVar(self, name, ilType, l.mutable, il::Val::Reg(slot));

                return;

            }

        }

    }

    let rhs = try lowerExpr(self, a.right);

    match a.left.value {

        case ast::NodeValue::Ident(_) => {

            // First try local variable lookup.

                    throw LowerError::ImmutableAssignment;

                }

                let leftTy = try typeOf(self, a.left);

                    // Aggregates and address-taken scalars are represented as

                    // pointers to stack memory. Store through the pointer.

                    let val = try useVar(self, v);

                    let dst = emitValToReg(self, val);

    switchToBlock(self, endBlock);

}

/// Lower a `for` loop over a range, array, or slice.

unsafe fn lowerFor 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node, f: ast::For) throws (LowerError) where 'arena: 'phase, 'phase: 'function {

    let info = resolver::forLoopInfoFor(self.low.resolver, node) else {

        throw LowerError::MissingMetadata;

    };

    match info {

        case resolver::ForLoopInfo::Range { valType, range, bindingName, indexName } => {

            let iter = ForIter::Collection { valVar, idxVar, dataReg, lengthVal, elemType };

            try lowerForLoop(self, &iter, f.body);

        }

    }

}

/// Lower a break statement.

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

    let ctx = currentLoop(self) else {

        if first.typeNode <> nil or t.catches.len > 1 {

            // Typed multi-catch: switch on global error tag.

            try lowerMultiCatch(self, t.catches, calleeInfo, base, tagReg, &mut mergeBlock);

        } else {

            // Single untyped catch clause.

            if let binding = first.binding {

                let case ast::NodeValue::Ident(name) = binding.value else {

                    throw LowerError::ExpectedIdentifier;

                };

                let errTy = *calleeInfo.throwList[0];

                let errVal = tvalPayloadVal(self, base, errTy, RESULT_VAL_OFFSET);

                let _ = newVar(self, name, ilType(self.low, errTy), false, errVal);

            }

            try lowerBlock(self, first.body);

            try emitMergeIfUnterminated(self, &mut mergeBlock);

        }

    } else if t.shouldPanic {

        // `try!` -- panic on error, emit unreachable since control won't continue.

        // TODO: We should have some kind of `panic` instruction?

        emit(self, il::Instr::Unreachable);

    for clauseNode, i in catches {

        let case ast::NodeValue::CatchClause(clause) = clauseNode.value

            else panic "lowerMultiCatch: expected CatchClause";

        try switchToAndSeal(self, blocks[i]);

        if let binding = clause.binding {

            let case ast::NodeValue::Ident(name) = binding.value else {

                throw LowerError::ExpectedIdentifier;

            };

            newVar(self, name, ilType(self.low, errTy), false, errVal);

        }

        try lowerBlock(self, clause.body);

        try emitMergeIfUnterminated(self, mergeBlock);

    }

    // Emit unreachable block if no catch-all.

    if defaultIdx == nil {

        try switchToAndSeal(self, defaultTarget);

    match node.value {

        case ast::NodeValue::Ident(_) => {

            // First try local variable lookup.

            // Otherwise fall back to global symbol lookup.

                set val = try useVar(self, v);

                    let typ = try typeOf(self, node);

                    let ptr = emitValToReg(self, val);

                    set val = emitRead(self, ptr, 0, typ);

                }

            } else {