}

}

/// Emit a jump to target if the current block hasn't terminated, then seal the target block.

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

        try emitJmp(self, target);

    }

    try sealBlock(self, target);

}

        return false;

    }

        case il::Instr::Ret { .. },

             il::Instr::Jmp { .. },

             il::Instr::Br { .. },

             il::Instr::Switch { .. },

             il::Instr::Unreachable =>

///     }

///

/// In the above example, the merge block stays `nil`, and no code is generated

/// after the `if`. The merge block is created on first use.

unsafe fn emitMergeIfUnterminated 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, mergeBlock: &mut ?BlockId) throws (LowerError) where 'arena: 'phase, 'phase: 'function {

        if *mergeBlock == nil {

            set *mergeBlock = try createBlock(self, "merge");

        }

        let target = *mergeBlock else { throw LowerError::MissingTarget; };

        try emitJmp(self, target);

    }

    /// Lower function body.

    try lowerBlock(self, body);

    // Add implicit return if body doesn't diverge.

        if *self.fnType.returnType == resolver::Type::Never {

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

        } else if self.fnType.throwList.len > 0 {

            if *self.fnType.returnType == resolver::Type::Void {

                // Implicit `void` return in throwing function: wrap in result success.

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

                    exitVarScope(&mut self.vars, savedVarsLen);

                    return;

                }

            }

            for bindingNode, i in bindings {

    let savedVarsLen = enterVarScope(&self.vars);

    for stmt in blk.statements {

        try lowerNode(self, stmt);

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

            exitVarScope(&mut self.vars, savedVarsLen);

            return;

        }

    }

    exitVarScope(&mut self.vars, savedVarsLen);

/// Lower a let binding.

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

    // Evaluate value.

    let val = try lowerExpr(self, l.value);

        return;

    }

    try bindLetValue(self, node, l, val);

}

        try emitJmpAndSeal(self, stepBlock);

        switchToBlock(self, stepBlock);

    }

    // Otherwise, emit increment directly in the current block,

    // saving the jump to a separate step block.

        match *iter {

            case ForIter::Range { valVar, valType, indexVar, .. } => {

                try emitIncrement(self, valVar, valType);

                if let idxVar = indexVar {

                    try emitIncrement(self, idxVar, il::Type::W32);

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

    let mut val = il::Val::Undef;

    if let expr = value {

        set val = try lowerExpr(self, expr);

    }

        return;

    }

    set val = try applyCoercion(self, node, val);

    try emitRetVal(self, val);

}

    } else if let case resolver::NodeExtra::MethodCall { method } = callNodeExtra {

        set resVal = try lowerMethodCall(self, t.expr, callExpr, method);

    } else {

        set resVal = try lowerCall(self, t.expr, callExpr);

    }

        return il::Val::Undef;

    }

    let base = emitValToReg(self, resVal); // The result value.

    let tagReg = resultTagReg(self, base); // The result tag.

    emitLoadW64At(

        self, functionReg, vtableReg,

        (allocation.methodIndex * resolver::PTR_SIZE) as i32,

    );

    let value = try lowerCallArg(self, call.args[0], true);

        return SessionInitialization { allocation, result: il::Val::Undef, value, count: il::Val::Undef };

    }

    let slice = allocation.kind <> resolver::SessionAllocationKind::New;

    let mut count = il::Val::Imm(1);

    if allocation.kind == resolver::SessionAllocationKind::Copy {

        set count = loadSliceLen(self, emitValToReg(self, value));

    } else if allocation.kind == resolver::SessionAllocationKind::Fill {

        set count = try lowerExpr(self, call.args[1]);

            return SessionInitialization { allocation, result: il::Val::Undef, value, count: il::Val::Undef };

        }

    }

    let layout = resolver::getTypeLayout(*allocation.item);

    let size = layout.size if layout.size > 0 else 1;