joule_mir/

build.rs

//! HIR to MIR lowering (builder)
//!
//! This module converts High-level IR (HIR) to Mid-level IR (MIR).
//! It handles:
//! - Breaking down expressions into basic blocks
//! - Converting control flow to explicit terminators
//! - Creating temporaries for intermediate values
//! - Converting patterns to explicit code

use crate::{
    AggregateKind, BasicBlock, BasicBlockId, Constant, FieldIdx, FunctionId, FunctionMIR, IntTy,
    Local, LocalDecl, Operand, Place, PlaceElem, Rvalue, Statement, SwitchTargets, Terminator, Ty,
    UintTy,
};
use joule_common::{Span, Symbol};
use joule_hir::{self as hir, HirId};
use joule_hir::{BinOp, Literal};
use std::collections::HashMap;

/// Loop context for break/continue targeting
struct LoopContext {
    /// Block to jump to on `continue`
    header: BasicBlockId,
    /// Block to jump to on `break`
    exit: BasicBlockId,
    /// Where `break VALUE` should store its result
    break_destination: Option<Place>,
}

/// Builder for constructing MIR from HIR
pub struct MirBuilder {
    /// The function being built
    func: FunctionMIR,
    /// Current basic block being built
    current_block: Option<BasicBlockId>,
    /// Map from HIR IDs to MIR locals
    hir_to_local: HashMap<HirId, Local>,
    /// Counter for generating unique local IDs
    _local_counter: u32,
    /// Blocks that need terminators filled in
    _incomplete_blocks: Vec<BasicBlockId>,
    /// Stack of loop contexts for break/continue
    loop_stack: Vec<LoopContext>,
    /// Map from (enum_name, variant_name) to discriminant index
    variant_index_map: HashMap<(String, String), u128>,
    /// Closure body functions built during parent function construction
    pending_closures: Vec<FunctionMIR>,
}

impl MirBuilder {
    /// Create a new MIR builder for a function
    pub fn new(id: FunctionId, name: Symbol, return_ty: Ty, span: Span) -> Self {
        Self {
            func: FunctionMIR::new(id, name, return_ty, span),
            current_block: None,
            hir_to_local: HashMap::new(),
            _local_counter: 1, // 0 is reserved for return place
            _incomplete_blocks: Vec::new(),
            loop_stack: Vec::new(),
            variant_index_map: HashMap::new(),
            pending_closures: Vec::new(),
        }
    }

    /// Create a new MIR builder with function attributes
    pub fn with_attributes(
        id: FunctionId,
        name: Symbol,
        return_ty: Ty,
        attributes: crate::FunctionAttributes,
        span: Span,
    ) -> Self {
        Self {
            func: FunctionMIR::with_attributes(id, name, return_ty, attributes, span),
            current_block: None,
            hir_to_local: HashMap::new(),
            _local_counter: 1,
            _incomplete_blocks: Vec::new(),
            loop_stack: Vec::new(),
            variant_index_map: HashMap::new(),
            pending_closures: Vec::new(),
        }
    }

    /// Build MIR for a HIR function
    pub fn build_function(hir_func: &hir::Function) -> (FunctionMIR, Vec<FunctionMIR>) {
        Self::build_function_with_enums(hir_func, &HashMap::new())
    }

    /// Build MIR for a HIR function, with enum variant index map for match lowering.
    /// Returns (main_function, closure_functions).
    pub fn build_function_with_enums(
        hir_func: &hir::Function,
        variant_index_map: &HashMap<(String, String), u128>,
    ) -> (FunctionMIR, Vec<FunctionMIR>) {
        let id = FunctionId::from_hir(hir_func.id);
        let return_ty = Ty::from_hir(&hir_func.return_ty);

        // Propagate function attributes from HIR to MIR
        let mut builder = Self::with_attributes(
            id,
            hir_func.name,
            return_ty.clone(),
            hir_func.attributes.clone(),
            hir_func.span,
        );
        builder.variant_index_map = variant_index_map.clone();

        // Update return place type
        builder.func.locals[0].ty = return_ty;

        // Create parameters
        for param in &hir_func.params {
            let local = builder.new_local(Some(param.pattern.ty().clone()), param.span, false);
            builder.func.params.push(local);

            // Map parameter pattern to local
            if let hir::Pattern::Ident { id, .. } = &param.pattern {
                builder.hir_to_local.insert(*id, local);
            }
        }

        // Create entry block
        let entry = builder.new_block();
        builder.current_block = Some(entry);

        // Build function body
        builder.build_block_expr(&hir_func.body, Place::return_place());

        // Ensure all blocks have terminators
        builder.ensure_return();

        let closures = builder.pending_closures;
        (builder.func, closures)
    }

    /// Create a new local variable
    fn new_local(&mut self, hir_ty: Option<hir::Ty>, span: Span, mutable: bool) -> Local {
        let ty = hir_ty.map(|t| Ty::from_hir(&t)).unwrap_or(Ty::Unit);
        let decl = LocalDecl::new(None, ty, mutable, span);
        self.func.add_local(decl)
    }

    /// Create a new temporary
    fn new_temp(&mut self, ty: Ty, span: Span) -> Local {
        let decl = LocalDecl::new(None, ty, true, span);
        self.func.add_local(decl)
    }

    /// Create a new basic block
    fn new_block(&mut self) -> BasicBlockId {
        let block = BasicBlock::new(Terminator::Unreachable {
            span: Span::dummy(),
        });
        self.func.add_block(block)
    }

    /// Get the current basic block
    fn current_block_mut(&mut self) -> &mut BasicBlock {
        let id = self.current_block.expect("No current block");
        self.func.block_mut(id)
    }

    /// Add a statement to the current block
    fn push_statement(&mut self, stmt: Statement) {
        self.current_block_mut().statements.push(stmt);
    }

    /// Set the terminator for the current block
    fn set_terminator(&mut self, terminator: Terminator) {
        let id = self.current_block.expect("No current block");
        self.func.block_mut(id).terminator = terminator;
        self.current_block = None;
    }

    /// Ensure the function has a proper return
    fn ensure_return(&mut self) {
        if let Some(block_id) = self.current_block {
            // If there's an active block, add a return
            let terminator = Terminator::Return {
                span: self.func.span,
            };
            self.func.block_mut(block_id).terminator = terminator;
        }
    }

    /// Build a block expression, storing result in destination
    fn build_block_expr(&mut self, block: &hir::Block, destination: Place) {
        // Storage live for all let bindings
        for stmt in &block.statements {
            self.build_statement(stmt);
            // If statement created a terminator (e.g., return), stop processing
            if self.current_block.is_none() {
                return;
            }
        }

        // Build the final expression (if any)
        if let Some(expr) = &block.expr {
            self.build_expr_into(expr, destination);
        } else {
            // No expression, assign unit
            self.push_statement(Statement::Assign {
                place: destination,
                rvalue: Rvalue::Aggregate {
                    kind: AggregateKind::Tuple,
                    operands: vec![],
                },
                span: block.span,
            });
        }
    }

    /// Build a statement
    fn build_statement(&mut self, stmt: &hir::Statement) {
        match stmt {
            hir::Statement::Let {
                pattern,
                ty,
                init,
                span,
                ..
            } => {
                match pattern {
                    hir::Pattern::Tuple { patterns, .. } => {
                        // Create temp for the whole tuple
                        let tuple_local = self.new_local(Some(ty.clone()), *span, false);
                        self.push_statement(Statement::StorageLive {
                            local: tuple_local,
                            span: *span,
                        });

                        // Build init into tuple temp
                        if let Some(init_expr) = init {
                            self.build_expr_into(init_expr, Place::from_local(tuple_local));
                        }

                        // Extract each field into its own local
                        for (i, sub_pat) in patterns.iter().enumerate() {
                            match sub_pat {
                                hir::Pattern::Ident {
                                    id: pat_id,
                                    mutable,
                                    ty: field_ty,
                                    ..
                                } => {
                                    let field_local =
                                        self.new_local(Some(field_ty.clone()), *span, *mutable);
                                    self.hir_to_local.insert(*pat_id, field_local);
                                    self.push_statement(Statement::StorageLive {
                                        local: field_local,
                                        span: *span,
                                    });
                                    self.push_statement(Statement::Assign {
                                        place: Place::from_local(field_local),
                                        rvalue: Rvalue::Use(Operand::Copy(
                                            Place::from_local(tuple_local)
                                                .field(FieldIdx::new(i as u32)),
                                        )),
                                        span: *span,
                                    });
                                }
                                hir::Pattern::Wildcard { .. } => {
                                    // No binding needed for wildcard
                                }
                                _ => {
                                    // Nested patterns: create a local for the sub-pattern
                                    let sub_local = self.new_local(Some(ty.clone()), *span, false);
                                    self.push_statement(Statement::StorageLive {
                                        local: sub_local,
                                        span: *span,
                                    });
                                    self.push_statement(Statement::Assign {
                                        place: Place::from_local(sub_local),
                                        rvalue: Rvalue::Use(Operand::Copy(
                                            Place::from_local(tuple_local)
                                                .field(FieldIdx::new(i as u32)),
                                        )),
                                        span: *span,
                                    });
                                }
                            }
                        }
                    }
                    _ => {
                        let mutable = matches!(pattern, hir::Pattern::Ident { mutable: true, .. });
                        let local = self.new_local(Some(ty.clone()), *span, mutable);

                        // Map HIR pattern to local, and set the name for codegen lookups
                        if let hir::Pattern::Ident {
                            id: pattern_id,
                            name,
                            ..
                        } = pattern
                        {
                            self.hir_to_local.insert(*pattern_id, local);
                            self.func.locals[local.0 as usize].name = Some(*name);
                        }

                        // Storage live
                        self.push_statement(Statement::StorageLive { local, span: *span });

                        // Initialize if there's an initializer
                        if let Some(init_expr) = init {
                            let place = Place::from_local(local);
                            self.build_expr_into(init_expr, place);
                        }
                    }
                }
            }
            hir::Statement::Expr(expr) => {
                // Expression statement - evaluate but discard result
                let temp = self.new_temp(Ty::from_hir(&expr.ty), expr.span);
                self.build_expr_into(expr, Place::from_local(temp));
            }
        }
    }

    /// Build an expression, storing result in destination
    fn build_expr_into(&mut self, expr: &hir::Expr, destination: Place) {
        match &expr.kind {
            hir::ExprKind::Literal(lit) => {
                let constant = Constant::new(lit.clone(), Ty::from_hir(&expr.ty), expr.span);
                self.push_statement(Statement::Assign {
                    place: destination,
                    rvalue: Rvalue::Use(Operand::Constant(constant)),
                    span: expr.span,
                });
            }

            hir::ExprKind::Var { def_id, name, .. } => {
                if let Some(&local) = self.hir_to_local.get(def_id) {
                    let place = Place::from_local(local);
                    let ty = Ty::from_hir(&expr.ty);
                    let operand = if ty.is_copy() {
                        Operand::Copy(place)
                    } else {
                        Operand::Move(place)
                    };
                    self.push_statement(Statement::Assign {
                        place: destination,
                        rvalue: Rvalue::Use(operand),
                        span: expr.span,
                    });
                } else {
                    // Check if this is an enum variant (e.g., TokenKind::Eof)
                    // Enum variants start with uppercase; regular variables don't
                    let name_str = name.as_str();
                    let is_enum_variant = name_str
                        .chars()
                        .next()
                        .map(|c| c.is_ascii_uppercase())
                        .unwrap_or(false);
                    if is_enum_variant {
                        self.push_statement(Statement::Assign {
                            place: destination,
                            rvalue: Rvalue::EnumVariant {
                                variant: *name,
                                fields: vec![],
                            },
                            span: expr.span,
                        });
                    }
                    // else: variable not found in hir_to_local — assignment silently skipped
                }
            }

            hir::ExprKind::Binary { op, left, right } => {
                let left_temp = self.new_temp(Ty::from_hir(&left.ty), left.span);
                let right_temp = self.new_temp(Ty::from_hir(&right.ty), right.span);

                self.build_expr_into(left, Place::from_local(left_temp));
                self.build_expr_into(right, Place::from_local(right_temp));

                self.push_statement(Statement::Assign {
                    place: destination,
                    rvalue: Rvalue::BinaryOp {
                        op: *op,
                        left: Operand::Copy(Place::from_local(left_temp)),
                        right: Operand::Copy(Place::from_local(right_temp)),
                    },
                    span: expr.span,
                });
            }

            hir::ExprKind::Unary { op, expr: inner } => {
                let temp = self.new_temp(Ty::from_hir(&inner.ty), inner.span);
                self.build_expr_into(inner, Place::from_local(temp));

                self.push_statement(Statement::Assign {
                    place: destination,
                    rvalue: Rvalue::UnaryOp {
                        op: *op,
                        operand: Operand::Copy(Place::from_local(temp)),
                    },
                    span: expr.span,
                });
            }

            hir::ExprKind::Tuple { elements } => {
                let mut operands = Vec::new();
                for elem in elements {
                    let temp = self.new_temp(Ty::from_hir(&elem.ty), elem.span);
                    self.build_expr_into(elem, Place::from_local(temp));
                    operands.push(Operand::Copy(Place::from_local(temp)));
                }

                self.push_statement(Statement::Assign {
                    place: destination,
                    rvalue: Rvalue::Aggregate {
                        kind: AggregateKind::Tuple,
                        operands,
                    },
                    span: expr.span,
                });
            }

            hir::ExprKind::Array { elements } => {
                let mut operands = Vec::new();
                let elem_ty = if let hir::Ty::Array { element, .. } = &expr.ty {
                    Ty::from_hir(element)
                } else {
                    Ty::Unit
                };

                for elem in elements {
                    let temp = self.new_temp(Ty::from_hir(&elem.ty), elem.span);
                    self.build_expr_into(elem, Place::from_local(temp));
                    operands.push(Operand::Copy(Place::from_local(temp)));
                }

                self.push_statement(Statement::Assign {
                    place: destination,
                    rvalue: Rvalue::Aggregate {
                        kind: AggregateKind::Array(elem_ty),
                        operands,
                    },
                    span: expr.span,
                });
            }

            hir::ExprKind::Struct {
                def_id,
                fields,
                variant_name,
            } => {
                let mut operands = Vec::new();
                // Sort fields by index
                let mut sorted_fields = fields.clone();
                sorted_fields.sort_by_key(|f| f.field_idx);

                for field in sorted_fields {
                    let temp = self.new_temp(Ty::from_hir(&field.value.ty), field.value.span);
                    self.build_expr_into(&field.value, Place::from_local(temp));
                    operands.push(Operand::Copy(Place::from_local(temp)));
                }

                self.push_statement(Statement::Assign {
                    place: destination,
                    rvalue: Rvalue::Aggregate {
                        kind: AggregateKind::Struct(*def_id, *variant_name),
                        operands,
                    },
                    span: expr.span,
                });
            }

            hir::ExprKind::Block(block) => {
                self.build_block_expr(block, destination);
            }

            hir::ExprKind::If {
                condition,
                then_block,
                else_block,
            } => {
                self.build_if(
                    condition,
                    then_block,
                    else_block.as_deref(),
                    destination,
                    expr.span,
                );
            }

            hir::ExprKind::Return { value } => {
                if let Some(val) = value {
                    self.build_expr_into(val, Place::return_place());
                }
                if self.current_block.is_some() {
                    self.set_terminator(Terminator::Return { span: expr.span });
                }
            }

            hir::ExprKind::Assign { target, value } => {
                // Build target place
                let target_place = self.build_place(target);
                self.build_expr_into(value, target_place);

                // Assign unit to destination
                self.push_statement(Statement::Assign {
                    place: destination,
                    rvalue: Rvalue::Aggregate {
                        kind: AggregateKind::Tuple,
                        operands: vec![],
                    },
                    span: expr.span,
                });
            }

            hir::ExprKind::Ref {
                mutable,
                expr: inner,
            } => {
                let place = self.build_place(inner);
                self.push_statement(Statement::Assign {
                    place: destination,
                    rvalue: Rvalue::Ref {
                        mutable: *mutable,
                        place,
                    },
                    span: expr.span,
                });
            }

            hir::ExprKind::Deref { expr: inner } => {
                let temp = self.new_temp(Ty::from_hir(&inner.ty), inner.span);
                self.build_expr_into(inner, Place::from_local(temp));

                let deref_place = Place::from_local(temp).deref();
                let ty = Ty::from_hir(&expr.ty);
                let operand = if ty.is_copy() {
                    Operand::Copy(deref_place)
                } else {
                    Operand::Move(deref_place)
                };

                self.push_statement(Statement::Assign {
                    place: destination,
                    rvalue: Rvalue::Use(operand),
                    span: expr.span,
                });
            }

            hir::ExprKind::Field {
                expr: inner,
                field_idx,
                ..
            } => {
                let temp = self.new_temp(Ty::from_hir(&inner.ty), inner.span);
                self.build_expr_into(inner, Place::from_local(temp));

                let field_place = Place::from_local(temp).field(FieldIdx::new(*field_idx as u32));
                let ty = Ty::from_hir(&expr.ty);
                let operand = if ty.is_copy() {
                    Operand::Copy(field_place)
                } else {
                    Operand::Move(field_place)
                };

                self.push_statement(Statement::Assign {
                    place: destination,
                    rvalue: Rvalue::Use(operand),
                    span: expr.span,
                });
            }

            hir::ExprKind::Cast {
                expr: inner,
                target_ty,
            } => {
                let temp = self.new_temp(Ty::from_hir(&inner.ty), inner.span);
                self.build_expr_into(inner, Place::from_local(temp));

                let cast_kind = self.determine_cast_kind(&inner.ty, target_ty);

                self.push_statement(Statement::Assign {
                    place: destination,
                    rvalue: Rvalue::Cast {
                        operand: Operand::Copy(Place::from_local(temp)),
                        target_ty: Ty::from_hir(target_ty),
                        kind: cast_kind,
                    },
                    span: expr.span,
                });
            }

            hir::ExprKind::Call { func, args } => {
                // Extract function name if it's a simple variable reference
                let func_name = if let hir::ExprKind::Var { name, .. } = &func.kind {
                    Some(*name)
                } else {
                    None
                };

                // Build function operand
                let func_temp = self.new_temp(Ty::from_hir(&func.ty), func.span);
                self.build_expr_into(func, Place::from_local(func_temp));

                // Build argument operands
                let mut arg_operands = Vec::new();
                for arg in args {
                    // Special case: keep string literals as constants
                    if let hir::ExprKind::Literal(lit @ hir::Literal::String(_)) = &arg.kind {
                        let constant = Constant::new(lit.clone(), Ty::from_hir(&arg.ty), arg.span);
                        arg_operands.push(Operand::Constant(constant));
                    } else {
                        let arg_temp = self.new_temp(Ty::from_hir(&arg.ty), arg.span);
                        self.build_expr_into(arg, Place::from_local(arg_temp));
                        arg_operands.push(Operand::Copy(Place::from_local(arg_temp)));
                    }
                }

                // Create a block to continue execution after the call
                let next_block = self.new_block();

                // Emit call terminator
                self.set_terminator(Terminator::Call {
                    func: Operand::Copy(Place::from_local(func_temp)),
                    func_name,
                    args: arg_operands,
                    destination: destination.clone(),
                    target: next_block,
                    span: expr.span,
                    is_virtual: false,
                });

                // Continue in next block
                self.current_block = Some(next_block);
            }

            // === Concurrency Expressions ===
            hir::ExprKind::Spawn { expr: spawn_expr } => {
                // Build the expression to spawn
                let spawn_temp = self.new_temp(Ty::from_hir(&spawn_expr.ty), spawn_expr.span);
                self.build_expr_into(spawn_expr, Place::from_local(spawn_temp));

                // Create block to continue in after spawn
                let next_block = self.new_block();

                // Emit spawn terminator
                self.set_terminator(Terminator::Spawn {
                    func: Operand::Copy(Place::from_local(spawn_temp)),
                    args: vec![],
                    destination: destination.clone(),
                    target: next_block,
                    span: expr.span,
                });

                self.current_block = Some(next_block);
            }

            hir::ExprKind::TaskGroup { body } => {
                // Create blocks for task group
                let group_temp = self.new_temp(Ty::TaskGroup, expr.span);
                let body_block = self.new_block();
                let join_block = self.new_block();

                // Enter task group
                self.set_terminator(Terminator::TaskGroupEnter {
                    destination: Place::from_local(group_temp),
                    body: body_block,
                    join_block,
                    span: expr.span,
                });

                // Build task group body
                self.current_block = Some(body_block);
                let body_result = self.new_temp(Ty::from_hir(&body.ty), body.span);
                self.build_block_expr(body, Place::from_local(body_result));

                // Exit task group (if we have a current block - may have returned)
                if self.current_block.is_some() {
                    let next_block = self.new_block();
                    self.set_terminator(Terminator::TaskGroupExit {
                        group: Operand::Copy(Place::from_local(group_temp)),
                        target: next_block,
                        span: expr.span,
                    });
                    self.current_block = Some(next_block);

                    // Copy result to destination
                    self.push_statement(Statement::Assign {
                        place: destination,
                        rvalue: Rvalue::Use(Operand::Copy(Place::from_local(body_result))),
                        span: expr.span,
                    });
                }

                // Continue in join block for structured completion
                self.current_block = Some(join_block);
            }

            hir::ExprKind::Channel {
                element_ty,
                capacity,
            } => {
                // Evaluate capacity expression
                let cap_temp = self.new_temp(Ty::Uint(UintTy::U64), capacity.span);
                self.build_expr_into(capacity, Place::from_local(cap_temp));

                // For now, use a constant capacity (we'll need proper const evaluation later)
                // Extract capacity value if it's a literal
                let cap_value = 16u64; // Default capacity

                self.push_statement(Statement::Assign {
                    place: destination,
                    rvalue: Rvalue::ChannelCreate {
                        element_ty: Ty::from_hir(element_ty),
                        capacity: cap_value,
                    },
                    span: expr.span,
                });
            }

            hir::ExprKind::Select { arms } => {
                self.build_select(arms, false, destination, expr.span);
            }

            hir::ExprKind::SelectBiased { arms } => {
                self.build_select(arms, true, destination, expr.span);
            }

            hir::ExprKind::Cancelled => {
                self.push_statement(Statement::Assign {
                    place: destination,
                    rvalue: Rvalue::IsCancelled,
                    span: expr.span,
                });
            }

            // Advanced concurrency features that require runtime support not yet
            // available in the MIR backend. Each of these needs:
            //
            // - SpawnWithDeadline: deadline-aware task scheduler in the runtime,
            //   cancellation token propagation, and timeout MIR instructions.
            // - TaskGroupAll: structured concurrency with join semantics,
            //   requiring TaskGroupEnter/TaskGroupExit with barrier support.
            // - Gpu: heterogeneous compute dispatch, requiring MLIR or SPIR-V
            //   codegen backend and device memory management.
            // - Distributed: remote execution and serialization of closures,
            //   requiring network transport and distributed runtime.
            // - SpawnRemote: remote node task dispatch, requiring node
            //   discovery and remote procedure call infrastructure.
            //
            // These abort at MIR level so the compiler produces a clear error
            // rather than silently generating incorrect code. The destination
            // is assigned unit to satisfy the type system before the abort.
            // Energy budget block: the budget is enforced at compile time
            // by the energy estimator. At runtime, just execute the body.
            hir::ExprKind::EnergyBudgetBlock { body, .. } => {
                self.build_block_expr(body, destination);
            }

            // Thermal adaptation: dispatch based on runtime thermal state.
            // Currently compiles the first arm as the default path. When the
            // runtime thermal API is available, this will generate a thermal
            // state query and branch to the appropriate arm.
            hir::ExprKind::ThermalAdapt { arms } => {
                if let Some(first_arm) = arms.first() {
                    self.build_expr_into(&first_arm.body, destination);
                } else {
                    self.push_statement(Statement::Assign {
                        place: destination,
                        rvalue: Rvalue::Aggregate {
                            kind: AggregateKind::Tuple,
                            operands: vec![],
                        },
                        span: expr.span,
                    });
                }
            }

            hir::ExprKind::SpawnWithDeadline { .. }
            | hir::ExprKind::TaskGroupAll { .. }
            | hir::ExprKind::Gpu { .. }
            | hir::ExprKind::Distributed { .. }
            | hir::ExprKind::SpawnRemote { .. } => {
                // Assign unit to destination for type-correctness in the
                // abort block. This value is never observed at runtime.
                self.push_statement(Statement::Assign {
                    place: destination,
                    rvalue: Rvalue::Aggregate {
                        kind: AggregateKind::Tuple,
                        operands: vec![],
                    },
                    span: expr.span,
                });

                // Terminate the current block with Abort. This makes the
                // unreachable nature of this code path explicit in the MIR,
                // enabling downstream passes (dead code elimination, energy
                // analysis) to correctly handle it.
                let feature_name = match &expr.kind {
                    hir::ExprKind::SpawnWithDeadline { .. } => "spawn_with_deadline",
                    hir::ExprKind::TaskGroupAll { .. } => "task_group_all",
                    hir::ExprKind::Gpu { .. } => "gpu",
                    hir::ExprKind::Distributed { .. } => "distributed",
                    hir::ExprKind::SpawnRemote { .. } => "spawn_remote",
                    _ => unreachable!(),
                };
                let _ = feature_name; // Used in diagnostic context
                self.set_terminator(Terminator::Abort { span: expr.span });

                // Create a new unreachable block for any subsequent code.
                // This prevents the builder from trying to add statements
                // to the terminated block.
                let unreachable_block = self.new_block();
                self.current_block = Some(unreachable_block);
            }

            // === Algebraic Effects ===
            // Perform: `perform IO::read()` — translate to function call
            hir::ExprKind::Perform { effect_name, operation, args } => {
                // Effects are compiled as calls to the effect handler function.
                // At MIR level, `perform` becomes a regular function call to
                // `__effect_{effect}_{op}` which the runtime resolves.
                let mut arg_ops = Vec::new();
                for arg in args {
                    let temp = self.new_temp(Ty::from_hir(&arg.ty), arg.span);
                    self.build_expr_into(arg, Place::from_local(temp));
                    arg_ops.push(Operand::Move(Place::from_local(temp)));
                }
                let func_name = format!("__effect_{}_{}", effect_name.as_str(), operation.as_str());
                let func_sym = Symbol::intern(&func_name);
                let func_temp = self.new_temp(
                    Ty::FnPtr {
                        params: arg_ops.iter().map(|_| Ty::Unit).collect(),
                        return_ty: Box::new(Ty::from_hir(&expr.ty)),
                    },
                    expr.span,
                );
                let next_block = self.new_block();
                self.set_terminator(Terminator::Call {
                    func: Operand::Copy(Place::from_local(func_temp)),
                    func_name: Some(func_sym),
                    args: arg_ops,
                    destination: destination.clone(),
                    target: next_block,
                    span: expr.span,
                    is_virtual: false,
                });
                self.current_block = Some(next_block);
            }

            // Handle: `handle { body } with { IO => handler }` — wraps body with handler
            // The body is compiled normally. Effect handlers are registered as
            // function pointers that `perform` calls resolve through.
            hir::ExprKind::Handle { body, .. } => {
                self.build_block_expr(body, destination);
            }

            // Parallel for: `parallel for x in iter { body }` — compiles like regular for
            // but with a hint to the C codegen to emit parallelism.
            // At MIR level, this is structurally identical to a regular for loop.
            hir::ExprKind::Parallel { iter, body, .. } => {
                let iter_temp = self.new_temp(Ty::from_hir(&iter.ty), iter.span);
                self.build_expr_into(iter, Place::from_local(iter_temp));

                // Build body as block expression
                self.build_block_expr(body, destination);
            }

            // Result builder: `build TypeName { body }` — at MIR level, lower the body.
            // The builder protocol (build_block, build_expression, build_optional)
            // transforms will be applied during a dedicated desugaring pass.
            hir::ExprKind::Build { body, .. } => {
                self.build_block_expr(body, destination);
            }

            // === Method call ===
            hir::ExprKind::MethodCall {
                receiver,
                method,
                args,
            } => {
                // Build receiver
                let recv_temp = self.new_temp(Ty::from_hir(&receiver.ty), receiver.span);
                self.build_expr_into(receiver, Place::from_local(recv_temp));

                // Build arguments (receiver is first arg)
                let mut arg_operands = vec![Operand::Copy(Place::from_local(recv_temp))];
                for arg in args {
                    let arg_temp = self.new_temp(Ty::from_hir(&arg.ty), arg.span);
                    self.build_expr_into(arg, Place::from_local(arg_temp));
                    arg_operands.push(Operand::Copy(Place::from_local(arg_temp)));
                }

                let next_block = self.new_block();

                // Check if receiver is a trait object (dyn Trait) for virtual dispatch
                let base_recv_ty = match &receiver.ty {
                    hir::Ty::Ref { inner, .. } => inner.as_ref(),
                    other => other,
                };
                let is_virtual = matches!(base_recv_ty, hir::Ty::TraitObject { .. });

                // Qualify the method name with the receiver type
                let recv_type_prefix = get_impl_type_prefix(&receiver.ty);
                let qualified_method =
                    Symbol::intern(&format!("{}::{}", recv_type_prefix, method.as_str()));

                // Use a function constant for the method
                let func_temp = self.new_temp(Ty::Unit, expr.span);
                self.set_terminator(Terminator::Call {
                    func: Operand::Copy(Place::from_local(func_temp)),
                    func_name: Some(qualified_method),
                    args: arg_operands,
                    destination: destination.clone(),
                    target: next_block,
                    span: expr.span,
                    is_virtual,
                });

                self.current_block = Some(next_block);
            }

            // === Match expression ===
            hir::ExprKind::Match {
                expr: scrutinee,
                arms,
            } => {
                // Build the scrutinee
                let scrut_temp = self.new_temp(Ty::from_hir(&scrutinee.ty), scrutinee.span);
                self.build_expr_into(scrutinee, Place::from_local(scrut_temp));

                // Save the block after scrutinee evaluation — we need to connect it
                // to the switch block after we create it
                let post_scrutinee_block = self.current_block;

                let join_block = self.new_block();

                // Build each arm as: body block that writes to destination then jumps to join
                let mut mir_arms = Vec::new();
                let mut arm_body_blocks = Vec::new();

                for arm in arms {
                    let body_block = self.new_block();
                    arm_body_blocks.push((body_block, arm));
                }

                // Check if any arm uses a Variant pattern (enum matching)
                let has_variant_arms = arm_body_blocks
                    .iter()
                    .any(|(_, arm)| matches!(&arm.pattern, hir::Pattern::Variant { .. }));

                for (idx, (body_block, arm)) in arm_body_blocks.iter().enumerate() {
                    // Build the arm body
                    self.current_block = Some(*body_block);

                    // Handle pattern bindings
                    if let hir::Pattern::Ident {
                        id,
                        name: _,
                        mutable: _,
                        ty,
                    } = &arm.pattern
                    {
                        let local = self.new_local(Some(ty.clone()), arm.body.span, false);
                        self.hir_to_local.insert(*id, local);
                        self.push_statement(Statement::Assign {
                            place: Place::from_local(local),
                            rvalue: Rvalue::Use(Operand::Copy(Place::from_local(scrut_temp))),
                            span: arm.body.span,
                        });
                    } else if let hir::Pattern::Variant {
                        fields,
                        variant_name,
                        ..
                    } = &arm.pattern
                    {
                        // Bind variant fields from the scrutinee
                        let variant_str = variant_name.as_str();
                        let is_result_option =
                            matches!(variant_str.as_str(), "Ok" | "Err" | "Some" | "None");

                        if is_result_option {
                            // For Result::Ok(s): s = scrutinee.ok (field 1)
                            // For Result::Err(e): e = scrutinee.err (field 2)
                            // For Option::Some(v): v = scrutinee.value (field 1)
                            let value_field_idx = match variant_str.as_str() {
                                "Ok" | "Some" => 1u32,
                                "Err" => 2u32,
                                _ => 1u32,
                            };
                            for (i, field_pat) in fields.iter().enumerate() {
                                if let hir::Pattern::Ident { id, ty, .. } = field_pat {
                                    let local =
                                        self.new_local(Some(ty.clone()), arm.body.span, false);
                                    self.hir_to_local.insert(*id, local);
                                    self.push_statement(Statement::Assign {
                                        place: Place::from_local(local),
                                        rvalue: Rvalue::Use(Operand::Copy(
                                            Place::from_local(scrut_temp)
                                                .field(FieldIdx::new(value_field_idx + i as u32)),
                                        )),
                                        span: arm.body.span,
                                    });
                                }
                            }
                        } else {
                            // Tagged union enum (e.g., TokenKind::Ident(name))
                            // Use Downcast projection: scrutinee.VariantName._i
                            for (i, field_pat) in fields.iter().enumerate() {
                                if let hir::Pattern::Ident { id, ty, .. } = field_pat {
                                    let local =
                                        self.new_local(Some(ty.clone()), arm.body.span, false);
                                    self.hir_to_local.insert(*id, local);
                                    self.push_statement(Statement::Assign {
                                        place: Place::from_local(local),
                                        rvalue: Rvalue::Use(Operand::Copy(
                                            Place::from_local(scrut_temp)
                                                .project(PlaceElem::Downcast(*variant_name))
                                                .field(FieldIdx::new(i as u32)),
                                        )),
                                        span: arm.body.span,
                                    });
                                }
                            }
                        }
                    }

                    // Handle guard expression: evaluate guard, branch on result
                    if let Some(guard) = &arm.guard {
                        let guard_temp = self.new_temp(Ty::Bool, guard.span);
                        self.build_expr_into(guard, Place::from_local(guard_temp));

                        // Create the real body block for when guard succeeds
                        let real_body_block = self.new_block();

                        // Guard failure falls through to the next arm's body, or join_block
                        let fallthrough = if idx + 1 < arm_body_blocks.len() {
                            arm_body_blocks[idx + 1].0
                        } else {
                            join_block
                        };

                        self.set_terminator(Terminator::SwitchInt {
                            discriminant: Operand::Copy(Place::from_local(guard_temp)),
                            targets: SwitchTargets::new(
                                vec![(1, real_body_block)],
                                fallthrough,
                            ),
                            span: guard.span,
                        });

                        self.current_block = Some(real_body_block);
                    }

                    self.build_expr_into(&arm.body, destination.clone());

                    if self.current_block.is_some() {
                        self.set_terminator(Terminator::Goto {
                            target: join_block,
                            span: arm.body.span,
                        });
                    }

                    // Convert HIR pattern to match lowering pattern
                    let pat = self.hir_pattern_to_mir_pat(&arm.pattern);
                    mir_arms.push((*body_block, pat));
                }

                // Build the switch: for now, simple literal/wildcard matching
                let switch_block = self.new_block();

                // Connect the post-scrutinee block to the switch block
                if let Some(post_scrut) = post_scrutinee_block {
                    self.current_block = Some(post_scrut);
                    self.set_terminator(Terminator::Goto {
                        target: switch_block,
                        span: expr.span,
                    });
                }

                self.current_block = Some(switch_block);

                // Detect string literal patterns in the original HIR arms
                let mut string_arms: Vec<(BasicBlockId, String)> = Vec::new();
                let mut string_otherwise: Option<BasicBlockId> = None;
                let has_string_patterns = arm_body_blocks.iter().any(|(_, arm)| {
                    matches!(
                        &arm.pattern,
                        hir::Pattern::Literal {
                            value: hir::LitValue::String(_),
                            ..
                        }
                    )
                });

                if has_string_patterns {
                    for (body_block, arm) in &arm_body_blocks {
                        match &arm.pattern {
                            hir::Pattern::Literal {
                                value: hir::LitValue::String(s),
                                ..
                            } => {
                                string_arms.push((*body_block, s.clone()));
                            }
                            _ => {
                                string_otherwise = Some(*body_block);
                            }
                        }
                    }
                }

                if has_string_patterns && !string_arms.is_empty() {
                    // Generate if-else chain for string pattern matching
                    let default_target = string_otherwise.unwrap_or(join_block);
                    for (i, (arm_block, lit_str)) in string_arms.iter().enumerate() {
                        // Create a temp for the string literal
                        let str_temp = self.new_temp(
                            Ty::Named {
                                def_id: joule_hir::HirId(u32::MAX),
                                name: Symbol::intern("str"),
                            },
                            expr.span,
                        );
                        self.push_statement(Statement::Assign {
                            place: Place::from_local(str_temp),
                            rvalue: Rvalue::Use(Operand::Constant(Constant::new(
                                Literal::String(lit_str.clone()),
                                Ty::Named {
                                    def_id: joule_hir::HirId(u32::MAX),
                                    name: Symbol::intern("str"),
                                },
                                expr.span,
                            ))),
                            span: expr.span,
                        });

                        // Create a temp for the comparison result
                        let cmp_temp = self.new_temp(Ty::Bool, expr.span);
                        self.push_statement(Statement::Assign {
                            place: Place::from_local(cmp_temp),
                            rvalue: Rvalue::BinaryOp {
                                op: BinOp::Eq,
                                left: Operand::Copy(Place::from_local(scrut_temp)),
                                right: Operand::Copy(Place::from_local(str_temp)),
                            },
                            span: expr.span,
                        });

                        // Determine the next comparison block or default
                        let next_target = if i + 1 < string_arms.len() {
                            self.new_block()
                        } else {
                            default_target
                        };

                        // SwitchInt: if equal → arm body, else → next comparison
                        self.set_terminator(Terminator::SwitchInt {
                            discriminant: Operand::Copy(Place::from_local(cmp_temp)),
                            targets: SwitchTargets::new(vec![(1, *arm_block)], next_target),
                            span: expr.span,
                        });

                        // Move to the next comparison block
                        if i + 1 < string_arms.len() {
                            self.current_block = Some(next_target);
                        }
                    }
                } else {
                    // Non-string pattern matching (original code)

                    let mut branches: Vec<(u128, BasicBlockId)> = Vec::new();
                    let mut otherwise = join_block;
                    let mut seen_discriminants = std::collections::HashSet::new();

                    // Collect range-pattern arms for if-else chain emission
                    let mut range_arms: Vec<(BasicBlockId, Option<i128>, Option<i128>, bool)> =
                        Vec::new();

                    for (body_block, pat) in &mir_arms {
                        match pat {
                            crate::match_lowering::Pat::Literal(lit) => {
                                let disc = lit.to_discriminant();
                                if seen_discriminants.insert(disc) {
                                    branches.push((disc, *body_block));
                                } else {
                                    otherwise = *body_block;
                                }
                            }
                            crate::match_lowering::Pat::Or(alternatives) => {
                                // Expand or-pattern: each literal alternative
                                // maps to the same body block
                                for alt in alternatives {
                                    if let crate::match_lowering::Pat::Literal(lit) = alt {
                                        let disc = lit.to_discriminant();
                                        if seen_discriminants.insert(disc) {
                                            branches.push((disc, *body_block));
                                        }
                                    }
                                }
                            }
                            crate::match_lowering::Pat::Range {
                                lo,
                                hi,
                                inclusive,
                            } => {
                                range_arms.push((*body_block, *lo, *hi, *inclusive));
                            }
                            crate::match_lowering::Pat::Wild
                            | crate::match_lowering::Pat::Bind { .. } => {
                                otherwise = *body_block;
                            }
                            _ => {
                                otherwise = *body_block;
                            }
                        }
                    }

                    if !range_arms.is_empty() && branches.is_empty() {
                        // Range-only matching: emit if-else chain
                        for (i, (arm_block, lo, hi, inclusive)) in
                            range_arms.iter().enumerate()
                        {
                            // lo_check: scrutinee >= lo
                            let mut checks = Vec::new();
                            if let Some(lo_val) = lo {
                                let lo_temp = self.new_temp(Ty::Bool, expr.span);
                                let lo_const = self.new_temp(
                                    Ty::from_hir(&scrutinee.ty),
                                    expr.span,
                                );
                                self.push_statement(Statement::Assign {
                                    place: Place::from_local(lo_const),
                                    rvalue: Rvalue::Use(Operand::Constant(Constant::new(
                                        Literal::Int(*lo_val as i64, IntTy::I64),
                                        Ty::from_hir(&scrutinee.ty),
                                        expr.span,
                                    ))),
                                    span: expr.span,
                                });
                                self.push_statement(Statement::Assign {
                                    place: Place::from_local(lo_temp),
                                    rvalue: Rvalue::BinaryOp {
                                        op: BinOp::Ge,
                                        left: Operand::Copy(Place::from_local(scrut_temp)),
                                        right: Operand::Copy(Place::from_local(lo_const)),
                                    },
                                    span: expr.span,
                                });
                                checks.push(lo_temp);
                            }
                            if let Some(hi_val) = hi {
                                let hi_temp = self.new_temp(Ty::Bool, expr.span);
                                let hi_const = self.new_temp(
                                    Ty::from_hir(&scrutinee.ty),
                                    expr.span,
                                );
                                self.push_statement(Statement::Assign {
                                    place: Place::from_local(hi_const),
                                    rvalue: Rvalue::Use(Operand::Constant(Constant::new(
                                        Literal::Int(*hi_val as i64, IntTy::I64),
                                        Ty::from_hir(&scrutinee.ty),
                                        expr.span,
                                    ))),
                                    span: expr.span,
                                });
                                let cmp_op = if *inclusive { BinOp::Le } else { BinOp::Lt };
                                self.push_statement(Statement::Assign {
                                    place: Place::from_local(hi_temp),
                                    rvalue: Rvalue::BinaryOp {
                                        op: cmp_op,
                                        left: Operand::Copy(Place::from_local(scrut_temp)),
                                        right: Operand::Copy(Place::from_local(hi_const)),
                                    },
                                    span: expr.span,
                                });
                                checks.push(hi_temp);
                            }

                            // AND the checks together
                            let result_temp = if checks.len() == 2 {
                                let and_temp = self.new_temp(Ty::Bool, expr.span);
                                self.push_statement(Statement::Assign {
                                    place: Place::from_local(and_temp),
                                    rvalue: Rvalue::BinaryOp {
                                        op: BinOp::BitAnd,
                                        left: Operand::Copy(Place::from_local(checks[0])),
                                        right: Operand::Copy(Place::from_local(checks[1])),
                                    },
                                    span: expr.span,
                                });
                                and_temp
                            } else if checks.len() == 1 {
                                checks[0]
                            } else {
                                // No bounds — always matches (open range)
                                let t = self.new_temp(Ty::Bool, expr.span);
                                self.push_statement(Statement::Assign {
                                    place: Place::from_local(t),
                                    rvalue: Rvalue::Use(Operand::Constant(Constant::new(
                                        Literal::Bool(true),
                                        Ty::Bool,
                                        expr.span,
                                    ))),
                                    span: expr.span,
                                });
                                t
                            };

                            let next_target =
                                if i + 1 < range_arms.len() {
                                    self.new_block()
                                } else {
                                    otherwise
                                };

                            self.set_terminator(Terminator::SwitchInt {
                                discriminant: Operand::Copy(Place::from_local(result_temp)),
                                targets: SwitchTargets::new(
                                    vec![(1, *arm_block)],
                                    next_target,
                                ),
                                span: expr.span,
                            });

                            if i + 1 < range_arms.len() {
                                self.current_block = Some(next_target);
                            }
                        }
                    } else if branches.is_empty() && range_arms.is_empty() {
                        // All wildcards — just goto the first arm
                        self.set_terminator(Terminator::Goto {
                            target: otherwise,
                            span: expr.span,
                        });
                    } else if has_variant_arms {
                        // Determine if this is Result/Option matching (bool discriminant)
                        // or regular enum matching (integer tag discriminant)
                        let is_result_option = arm_body_blocks.iter().any(|(_, arm)| {
                            if let hir::Pattern::Variant { variant_name, .. } = &arm.pattern {
                                let vs = variant_name.as_str();
                                matches!(vs.as_str(), "Ok" | "Err" | "Some" | "None")
                            } else {
                                false
                            }
                        });

                        if is_result_option {
                            // Check if any variant arm has literal inner fields
                            // (e.g., Some(' '), Some('/'))
                            let has_inner_literals = arm_body_blocks.iter().any(|(_, arm)| {
                                if let hir::Pattern::Variant { fields, .. } = &arm.pattern {
                                    fields
                                        .iter()
                                        .any(|f| matches!(f, hir::Pattern::Literal { .. }))
                                } else {
                                    false
                                }
                            });

                            if has_inner_literals {
                                // Two-level matching: first on is_some/is_ok, then on inner value
                                let mut some_ok_literal_arms: Vec<(BasicBlockId, u128)> =
                                    Vec::new();
                                let mut some_ok_otherwise: Option<BasicBlockId> = None;
                                let mut none_err_block: Option<BasicBlockId> = None;
                                let mut wildcard_block: Option<BasicBlockId> = None;

                                for (body_block, arm) in &arm_body_blocks {
                                    match &arm.pattern {
                                        hir::Pattern::Variant {
                                            variant_name,
                                            fields,
                                            ..
                                        } => {
                                            let vs = variant_name.as_str();
                                            match vs.as_str() {
                                                "Some" | "Ok" => {
                                                    if let Some(hir::Pattern::Literal {
                                                        value,
                                                        ..
                                                    }) = fields.first()
                                                    {
                                                        let disc = match value {
                                                            hir::LitValue::Int(n) => *n as u128,
                                                            hir::LitValue::Char(c) => *c as u128,
                                                            hir::LitValue::Bool(b) => {
                                                                if *b {
                                                                    1u128
                                                                } else {
                                                                    0u128
                                                                }
                                                            }
                                                            _ => 0u128,
                                                        };
                                                        some_ok_literal_arms
                                                            .push((*body_block, disc));
                                                    } else {
                                                        // Some(x) binding — catch-all for inner switch
                                                        some_ok_otherwise = Some(*body_block);
                                                    }
                                                }
                                                "None" | "Err" => {
                                                    none_err_block = Some(*body_block);
                                                }
                                                _ => {}
                                            }
                                        }
                                        _ => {
                                            wildcard_block = Some(*body_block);
                                        }
                                    }
                                }

                                let overall_otherwise = wildcard_block.unwrap_or(join_block);
                                let false_target = none_err_block.unwrap_or(overall_otherwise);
                                let inner_otherwise =
                                    some_ok_otherwise.unwrap_or(overall_otherwise);

                                // Level 1: SwitchInt on is_some/is_ok (field 0)
                                let disc_temp = self.new_temp(Ty::Bool, expr.span);
                                self.push_statement(Statement::Assign {
                                    place: Place::from_local(disc_temp),
                                    rvalue: Rvalue::Use(Operand::Copy(
                                        Place::from_local(scrut_temp).field(FieldIdx::new(0)),
                                    )),
                                    span: expr.span,
                                });

                                let inner_switch_block = self.new_block();
                                self.set_terminator(Terminator::SwitchInt {
                                    discriminant: Operand::Copy(Place::from_local(disc_temp)),
                                    targets: SwitchTargets::new(
                                        vec![(1, inner_switch_block)],
                                        false_target,
                                    ),
                                    span: expr.span,
                                });

                                // Level 2: extract .value (field 1) and switch on it
                                self.current_block = Some(inner_switch_block);
                                let value_temp = self.new_temp(Ty::Int(IntTy::I32), expr.span);
                                self.push_statement(Statement::Assign {
                                    place: Place::from_local(value_temp),
                                    rvalue: Rvalue::Use(Operand::Copy(
                                        Place::from_local(scrut_temp).field(FieldIdx::new(1)),
                                    )),
                                    span: expr.span,
                                });

                                let mut inner_branches: Vec<(u128, BasicBlockId)> = Vec::new();
                                let mut inner_seen = std::collections::HashSet::new();
                                for (block, disc) in &some_ok_literal_arms {
                                    if inner_seen.insert(*disc) {
                                        inner_branches.push((*disc, *block));
                                    }
                                }

                                self.set_terminator(Terminator::SwitchInt {
                                    discriminant: Operand::Copy(Place::from_local(value_temp)),
                                    targets: SwitchTargets::new(inner_branches, inner_otherwise),
                                    span: expr.span,
                                });
                            } else {
                                // Single-level Result/Option matching (no inner literals)
                                let disc_temp = self.new_temp(Ty::Bool, expr.span);
                                self.push_statement(Statement::Assign {
                                    place: Place::from_local(disc_temp),
                                    rvalue: Rvalue::Use(Operand::Copy(
                                        Place::from_local(scrut_temp).field(FieldIdx::new(0)),
                                    )),
                                    span: expr.span,
                                });
                                self.set_terminator(Terminator::SwitchInt {
                                    discriminant: Operand::Copy(Place::from_local(disc_temp)),
                                    targets: SwitchTargets::new(branches, otherwise),
                                    span: expr.span,
                                });
                            }
                        } else {
                            // Regular enum: field 0 is tag (integer)
                            let disc_temp = self.new_temp(Ty::Int(IntTy::I32), expr.span);
                            self.push_statement(Statement::Assign {
                                place: Place::from_local(disc_temp),
                                rvalue: Rvalue::Use(Operand::Copy(
                                    Place::from_local(scrut_temp).field(FieldIdx::new(0)),
                                )),
                                span: expr.span,
                            });
                            self.set_terminator(Terminator::SwitchInt {
                                discriminant: Operand::Copy(Place::from_local(disc_temp)),
                                targets: SwitchTargets::new(branches, otherwise),
                                span: expr.span,
                            });
                        }
                    } else {
                        self.set_terminator(Terminator::SwitchInt {
                            discriminant: Operand::Copy(Place::from_local(scrut_temp)),
                            targets: SwitchTargets::new(branches, otherwise),
                            span: expr.span,
                        });
                    }
                } // end of else (non-string pattern matching)

                self.current_block = Some(join_block);
            }

            // === While loop ===
            hir::ExprKind::While { condition, body } => {
                let cond_block = self.new_block();
                let body_block = self.new_block();
                let exit_block = self.new_block();

                // Jump to condition block
                self.set_terminator(Terminator::Goto {
                    target: cond_block,
                    span: expr.span,
                });

                // Build condition
                self.current_block = Some(cond_block);
                let cond_temp = self.new_temp(Ty::Bool, condition.span);
                self.build_expr_into(condition, Place::from_local(cond_temp));

                self.set_terminator(Terminator::SwitchInt {
                    discriminant: Operand::Copy(Place::from_local(cond_temp)),
                    targets: SwitchTargets::if_else(body_block, exit_block),
                    span: expr.span,
                });

                // Build body
                self.current_block = Some(body_block);
                self.loop_stack.push(LoopContext {
                    header: cond_block,
                    exit: exit_block,
                    break_destination: None,
                });

                let body_temp = self.new_temp(Ty::Unit, body.span);
                self.build_block_expr(body, Place::from_local(body_temp));

                self.loop_stack.pop();

                // Loop back to condition
                if self.current_block.is_some() {
                    self.set_terminator(Terminator::Goto {
                        target: cond_block,
                        span: expr.span,
                    });
                }

                // Continue after loop
                self.current_block = Some(exit_block);

                // While produces unit
                self.push_statement(Statement::Assign {
                    place: destination,
                    rvalue: Rvalue::Aggregate {
                        kind: AggregateKind::Tuple,
                        operands: vec![],
                    },
                    span: expr.span,
                });
            }

            // === Infinite loop ===
            hir::ExprKind::Loop { body } => {
                let loop_block = self.new_block();
                let exit_block = self.new_block();

                // Jump to loop body
                self.set_terminator(Terminator::Goto {
                    target: loop_block,
                    span: expr.span,
                });

                // Build body
                self.current_block = Some(loop_block);
                self.loop_stack.push(LoopContext {
                    header: loop_block,
                    exit: exit_block,
                    break_destination: Some(destination.clone()),
                });

                let body_temp = self.new_temp(Ty::from_hir(&body.ty), body.span);
                self.build_block_expr(body, Place::from_local(body_temp));

                self.loop_stack.pop();

                // Loop back
                if self.current_block.is_some() {
                    self.set_terminator(Terminator::Goto {
                        target: loop_block,
                        span: expr.span,
                    });
                }

                // Continue after loop (only reachable via break)
                self.current_block = Some(exit_block);
            }

            // === For loop (desugared to while with iterator) ===
            hir::ExprKind::For {
                pattern,
                iter,
                body,
            } => {
                // Build iterator expression
                // Unwrap Ref types since iter() in bootstrap passes through the receiver
                let raw_iter_ty = Ty::from_hir(&iter.ty);
                let iter_ty = match raw_iter_ty {
                    Ty::Ref { inner, .. } => *inner,
                    other => other,
                };

                // Check if iterating over a Range/RangeInclusive
                let range_info = match &iter_ty {
                    Ty::Named { name, .. } => {
                        let name_str = name.as_str();
                        if name_str == "Range" {
                            Some(false) // exclusive: start..end
                        } else if name_str == "RangeInclusive" {
                            Some(true) // inclusive: start..=end
                        } else {
                            None
                        }
                    }
                    _ => None,
                };

                if let Some(inclusive) = range_info {
                    // === Range-based for loop ===
                    // Decompose the Range struct literal into start/end values
                    // and generate a counter-based loop (no Range struct in MIR)

                    // Determine element type from the struct literal's start field
                    let elem_ty = if let hir::ExprKind::Struct { fields, .. } = &iter.kind {
                        fields
                            .iter()
                            .find(|f| f.name.as_str() == "start")
                            .map(|f| {
                                let t = Ty::from_hir(&f.value.ty);
                                if matches!(t, Ty::Unit) {
                                    Ty::Int(IntTy::I32)
                                } else {
                                    t
                                }
                            })
                            .unwrap_or(Ty::Int(IntTy::I32))
                    } else {
                        Ty::Int(IntTy::I32)
                    };

                    // Build start and end values from the struct literal fields
                    let start_temp = self.new_temp(elem_ty.clone(), expr.span);
                    let end_temp = self.new_temp(elem_ty.clone(), expr.span);

                    if let hir::ExprKind::Struct { fields, .. } = &iter.kind {
                        for field in fields {
                            if field.name.as_str() == "start" {
                                self.build_expr_into(&field.value, Place::from_local(start_temp));
                            } else if field.name.as_str() == "end" {
                                self.build_expr_into(&field.value, Place::from_local(end_temp));
                            }
                        }
                    }

                    // Initialize counter to start value
                    let counter_temp = self.new_temp(elem_ty.clone(), expr.span);
                    self.push_statement(Statement::Assign {
                        place: Place::from_local(counter_temp),
                        rvalue: Rvalue::Use(Operand::Copy(Place::from_local(start_temp))),
                        span: expr.span,
                    });

                    let cond_block = self.new_block();
                    let body_block = self.new_block();
                    let increment_block = self.new_block();
                    let exit_block = self.new_block();

                    // Jump to condition check
                    self.set_terminator(Terminator::Goto {
                        target: cond_block,
                        span: expr.span,
                    });

                    // Condition: counter < end (exclusive) or counter <= end (inclusive)
                    self.current_block = Some(cond_block);
                    let cond_temp = self.new_temp(Ty::Bool, expr.span);
                    let cmp_op = if inclusive {
                        hir::BinOp::Le
                    } else {
                        hir::BinOp::Lt
                    };
                    self.push_statement(Statement::Assign {
                        place: Place::from_local(cond_temp),
                        rvalue: Rvalue::BinaryOp {
                            op: cmp_op,
                            left: Operand::Copy(Place::from_local(counter_temp)),
                            right: Operand::Copy(Place::from_local(end_temp)),
                        },
                        span: expr.span,
                    });

                    self.set_terminator(Terminator::SwitchInt {
                        discriminant: Operand::Copy(Place::from_local(cond_temp)),
                        targets: SwitchTargets::if_else(body_block, exit_block),
                        span: expr.span,
                    });

                    // Body: bind pattern to counter value, execute body
                    self.current_block = Some(body_block);
                    // `continue` jumps to increment_block (not cond_block) so the
                    // loop counter is always incremented before re-checking the condition.
                    self.loop_stack.push(LoopContext {
                        header: increment_block,
                        exit: exit_block,
                        break_destination: None,
                    });

                    // Bind loop variable to current counter value
                    if let hir::Pattern::Ident { id, ty, .. } = pattern {
                        let pat_ty = match ty {
                            hir::Ty::Error | hir::Ty::Infer(_) => elem_ty.clone(),
                            _ => Ty::from_hir(ty),
                        };
                        let elem_local = self.new_temp(pat_ty, body.span);
                        self.hir_to_local.insert(*id, elem_local);

                        self.push_statement(Statement::Assign {
                            place: Place::from_local(elem_local),
                            rvalue: Rvalue::Use(Operand::Copy(Place::from_local(counter_temp))),
                            span: body.span,
                        });
                    }

                    let body_result = self.new_temp(Ty::Unit, body.span);
                    self.build_block_expr(body, Place::from_local(body_result));

                    self.loop_stack.pop();

                    // Fall through from body to increment block
                    if self.current_block.is_some() {
                        self.set_terminator(Terminator::Goto {
                            target: increment_block,
                            span: expr.span,
                        });
                    }

                    // Increment block: counter++ then jump back to condition
                    // `continue` also lands here, ensuring the counter always advances.
                    self.current_block = Some(increment_block);
                    let one = Operand::Constant(Constant::new(
                        hir::Literal::Int(1, hir::IntTy::I32),
                        elem_ty,
                        expr.span,
                    ));
                    self.push_statement(Statement::Assign {
                        place: Place::from_local(counter_temp),
                        rvalue: Rvalue::BinaryOp {
                            op: hir::BinOp::Add,
                            left: Operand::Copy(Place::from_local(counter_temp)),
                            right: one,
                        },
                        span: expr.span,
                    });

                    self.set_terminator(Terminator::Goto {
                        target: cond_block,
                        span: expr.span,
                    });

                    // Exit block
                    self.current_block = Some(exit_block);

                    // For produces unit
                    self.push_statement(Statement::Assign {
                        place: destination,
                        rvalue: Rvalue::Aggregate {
                            kind: AggregateKind::Tuple,
                            operands: vec![],
                        },
                        span: expr.span,
                    });
                } else {
                    // === Collection-based for loop (Vec, Array, etc.) ===
                    // Index-based desugaring: for i in 0..len { elem = coll[i]; body }

                    // When iterating `for x in &v`, unwrap the Ref and iterate
                    // over the underlying collection directly (by value copy).
                    // This avoids storing a reference in a non-ref temp.
                    let actual_iter = match &iter.kind {
                        hir::ExprKind::Ref { expr: inner, .. } => inner.as_ref(),
                        _ => iter,
                    };
                    let iter_temp = self.new_temp(iter_ty, actual_iter.span);
                    self.build_expr_into(actual_iter, Place::from_local(iter_temp));

                    // Create a counter/index for iteration
                    let idx_temp = self.new_temp(Ty::Uint(UintTy::U64), expr.span);
                    self.push_statement(Statement::Assign {
                        place: Place::from_local(idx_temp),
                        rvalue: Rvalue::Use(Operand::Constant(Constant::new(
                            hir::Literal::Uint(0, hir::UintTy::U64),
                            Ty::Uint(UintTy::U64),
                            expr.span,
                        ))),
                        span: expr.span,
                    });

                    // Get length
                    let len_temp = self.new_temp(Ty::Uint(UintTy::U64), expr.span);
                    self.push_statement(Statement::Assign {
                        place: Place::from_local(len_temp),
                        rvalue: Rvalue::Len {
                            place: Place::from_local(iter_temp),
                        },
                        span: expr.span,
                    });

                    let cond_block = self.new_block();
                    let body_block = self.new_block();
                    let increment_block = self.new_block();
                    let exit_block = self.new_block();

                    // Jump to condition
                    self.set_terminator(Terminator::Goto {
                        target: cond_block,
                        span: expr.span,
                    });

                    // Condition: idx < len
                    self.current_block = Some(cond_block);
                    let cond_temp = self.new_temp(Ty::Bool, expr.span);
                    self.push_statement(Statement::Assign {
                        place: Place::from_local(cond_temp),
                        rvalue: Rvalue::BinaryOp {
                            op: hir::BinOp::Lt,
                            left: Operand::Copy(Place::from_local(idx_temp)),
                            right: Operand::Copy(Place::from_local(len_temp)),
                        },
                        span: expr.span,
                    });

                    self.set_terminator(Terminator::SwitchInt {
                        discriminant: Operand::Copy(Place::from_local(cond_temp)),
                        targets: SwitchTargets::if_else(body_block, exit_block),
                        span: expr.span,
                    });

                    // Body: bind pattern to current element, execute body
                    self.current_block = Some(body_block);
                    // `continue` jumps to increment_block so the index always advances.
                    self.loop_stack.push(LoopContext {
                        header: increment_block,
                        exit: exit_block,
                        break_destination: None,
                    });

                    // Bind loop variable
                    if let hir::Pattern::Ident { id, ty, .. } = pattern {
                        // Infer element type from iterator when pattern type is Error
                        let elem_ty = match ty {
                            hir::Ty::Error | hir::Ty::Infer(_) => {
                                let iter_mir_ty = &self.func.locals[iter_temp.0 as usize].ty;
                                match iter_mir_ty {
                                    Ty::Generic { args, .. } if !args.is_empty() => args[0].clone(),
                                    Ty::Array { element, .. } => (**element).clone(),
                                    Ty::Slice { element } => (**element).clone(),
                                    _ => Ty::from_hir(ty),
                                }
                            }
                            _ => Ty::from_hir(ty),
                        };
                        let elem_local = self.new_temp(elem_ty, body.span);
                        self.hir_to_local.insert(*id, elem_local);

                        // elem = iter[idx]
                        let indexed_place = Place::from_local(iter_temp).index(idx_temp);
                        self.push_statement(Statement::Assign {
                            place: Place::from_local(elem_local),
                            rvalue: Rvalue::Use(Operand::Copy(indexed_place)),
                            span: body.span,
                        });
                    }

                    let body_result = self.new_temp(Ty::Unit, body.span);
                    self.build_block_expr(body, Place::from_local(body_result));

                    self.loop_stack.pop();

                    // Fall through from body to increment block
                    if self.current_block.is_some() {
                        self.set_terminator(Terminator::Goto {
                            target: increment_block,
                            span: expr.span,
                        });
                    }

                    // Increment block: idx++ then jump back to condition
                    // `continue` also lands here, ensuring the index always advances.
                    self.current_block = Some(increment_block);
                    let one = Operand::Constant(Constant::new(
                        hir::Literal::Uint(1, hir::UintTy::U64),
                        Ty::Uint(UintTy::U64),
                        expr.span,
                    ));
                    self.push_statement(Statement::Assign {
                        place: Place::from_local(idx_temp),
                        rvalue: Rvalue::BinaryOp {
                            op: hir::BinOp::Add,
                            left: Operand::Copy(Place::from_local(idx_temp)),
                            right: one,
                        },
                        span: expr.span,
                    });

                    self.set_terminator(Terminator::Goto {
                        target: cond_block,
                        span: expr.span,
                    });

                    // Exit block
                    self.current_block = Some(exit_block);

                    // For produces unit
                    self.push_statement(Statement::Assign {
                        place: destination,
                        rvalue: Rvalue::Aggregate {
                            kind: AggregateKind::Tuple,
                            operands: vec![],
                        },
                        span: expr.span,
                    });
                }
            }

            // === Break ===
            hir::ExprKind::Break { value } => {
                if let Some(loop_ctx) = self.loop_stack.last() {
                    let exit = loop_ctx.exit;
                    let break_dest = loop_ctx.break_destination.clone();
                    // Write break value to the loop's destination (not the
                    // throwaway temp from Statement::Expr)
                    if let Some(val) = value {
                        if let Some(dest) = break_dest {
                            self.build_expr_into(val, dest);
                        } else {
                            self.build_expr_into(val, destination.clone());
                        }
                    }
                    self.set_terminator(Terminator::Goto {
                        target: exit,
                        span: expr.span,
                    });
                }
            }

            // === Continue ===
            hir::ExprKind::Continue => {
                if let Some(loop_ctx) = self.loop_stack.last() {
                    let header = loop_ctx.header;
                    self.set_terminator(Terminator::Goto {
                        target: header,
                        span: expr.span,
                    });
                }
            }

            // === Index expression ===
            hir::ExprKind::Index { expr: inner, index } => {
                let inner_temp = self.new_temp(Ty::from_hir(&inner.ty), inner.span);
                self.build_expr_into(inner, Place::from_local(inner_temp));

                let index_temp = self.new_temp(Ty::from_hir(&index.ty), index.span);
                self.build_expr_into(index, Place::from_local(index_temp));

                let indexed_place = Place::from_local(inner_temp).index(index_temp);
                let ty = Ty::from_hir(&expr.ty);
                let operand = if ty.is_copy() {
                    Operand::Copy(indexed_place)
                } else {
                    Operand::Move(indexed_place)
                };

                self.push_statement(Statement::Assign {
                    place: destination,
                    rvalue: Rvalue::Use(operand),
                    span: expr.span,
                });
            }

            // === Multi-dimensional index: arr[i, j] or arr[1..5, ::2] ===
            hir::ExprKind::MultiDimIndex {
                expr: inner,
                indices,
            } => {
                let inner_ty = Ty::from_hir(&inner.ty);
                let inner_temp = self.new_temp(inner_ty.clone(), inner.span);
                self.build_expr_into(inner, Place::from_local(inner_temp));

                let result_ty = Ty::from_hir(&expr.ty);

                // Check if all indices are single (scalar access → _get call)
                let all_single = indices
                    .iter()
                    .all(|ic| matches!(ic, hir::HirIndexComponent::Single(_)));

                // Build ndarray method name from the inner type
                let ndarray_prefix = ndarray_type_prefix(&inner_ty);

                if all_single {
                    // Scalar access: ndarray_get(&arr, i0, i1, ...)
                    let func_name = format!("{ndarray_prefix}_get");
                    let func_sym = joule_common::Symbol::intern(&func_name);

                    // Create a temporary for the function pointer (required by Terminator::Call)
                    let fn_temp = self.new_temp(
                        Ty::FnPtr {
                            params: vec![],
                            return_ty: Box::new(result_ty.clone()),
                        },
                        expr.span,
                    );

                    let mut args = vec![Operand::Copy(Place::from_local(inner_temp))];
                    for ic in indices {
                        if let hir::HirIndexComponent::Single(idx_expr) = ic {
                            let idx_temp =
                                self.new_temp(Ty::from_hir(&idx_expr.ty), idx_expr.span);
                            self.build_expr_into(idx_expr, Place::from_local(idx_temp));
                            args.push(Operand::Copy(Place::from_local(idx_temp)));
                        }
                    }

                    let next_block = self.new_block();
                    self.set_terminator(Terminator::Call {
                        func: Operand::Copy(Place::from_local(fn_temp)),
                        func_name: Some(func_sym),
                        args,
                        destination,
                        target: next_block,
                        span: expr.span,
                        is_virtual: false,
                    });
                    self.current_block = Some(next_block);
                } else {
                    // Slicing — produces an NDView via stride manipulation.
                    // Full implementation in Phase 3 (C codegen for slice ops).
                    let func_name = format!("{ndarray_prefix}_slice");
                    let func_sym = joule_common::Symbol::intern(&func_name);

                    let fn_temp = self.new_temp(
                        Ty::FnPtr {
                            params: vec![],
                            return_ty: Box::new(result_ty.clone()),
                        },
                        expr.span,
                    );

                    let args = vec![Operand::Copy(Place::from_local(inner_temp))];

                    let next_block = self.new_block();
                    self.set_terminator(Terminator::Call {
                        func: Operand::Copy(Place::from_local(fn_temp)),
                        func_name: Some(func_sym),
                        args,
                        destination,
                        target: next_block,
                        span: expr.span,
                        is_virtual: false,
                    });
                    self.current_block = Some(next_block);
                }
            }

            // === Array repeat [value; count] ===
            hir::ExprKind::ArrayRepeat { element, count } => {
                let elem_temp = self.new_temp(Ty::from_hir(&element.ty), element.span);
                self.build_expr_into(element, Place::from_local(elem_temp));

                let mut operands = Vec::new();
                for _ in 0..*count {
                    operands.push(Operand::Copy(Place::from_local(elem_temp)));
                }

                let elem_ty = Ty::from_hir(&element.ty);
                self.push_statement(Statement::Assign {
                    place: destination,
                    rvalue: Rvalue::Aggregate {
                        kind: AggregateKind::Array(elem_ty),
                        operands,
                    },
                    span: expr.span,
                });
            }

            // === Try operator: expr? ===
            hir::ExprKind::Await { expr: inner } => {
                // Evaluate the future/task expression
                let task_temp = self.new_temp(Ty::from_hir(&inner.ty), inner.span);
                self.build_expr_into(inner, Place::from_local(task_temp));

                // Create block to continue in after await
                let next_block = self.new_block();

                // Emit TaskAwait terminator — blocks until the task produces a result
                self.set_terminator(Terminator::TaskAwait {
                    task: Operand::Move(Place::from_local(task_temp)),
                    destination: destination.clone(),
                    target: next_block,
                    span: expr.span,
                });

                self.current_block = Some(next_block);
            }

            hir::ExprKind::Try { expr: inner } => {
                let inner_temp = self.new_temp(Ty::from_hir(&inner.ty), inner.span);
                self.build_expr_into(inner, Place::from_local(inner_temp));

                self.push_statement(Statement::Assign {
                    place: destination,
                    rvalue: Rvalue::Try(Operand::Move(Place::from_local(inner_temp))),
                    span: expr.span,
                });
            }

            hir::ExprKind::Path { segments } => {
                // Path expression like EnumName::VariantName
                // Create an enum variant construction
                self.push_statement(Statement::Assign {
                    place: destination,
                    rvalue: Rvalue::EnumVariant {
                        variant: segments
                            .last()
                            .cloned()
                            .unwrap_or_else(|| joule_common::Symbol::intern("unknown")),
                        fields: vec![],
                    },
                    span: expr.span,
                });
            }

            hir::ExprKind::Closure {
                params,
                return_ty,
                body,
                captures,
                is_move,
            } => {
                // Get the closure id from the destination local's type (assigned by typechecker).
                // This ensures the aggregate ID matches the local's Ty::Closure ID.
                let closure_id = if let Ty::Closure { id, .. } =
                    &self.func.locals[destination.local.0 as usize].ty
                {
                    *id
                } else {
                    expr.id.0 // fallback for non-typed destinations
                };
                let closure_ty = Ty::Closure {
                    id: closure_id,
                    params: params.iter().map(|p| Ty::from_hir(&p.ty)).collect(),
                    return_ty: Box::new(Ty::from_hir(return_ty)),
                    capture_tys: captures.iter().map(|c| Ty::from_hir(&c.ty)).collect(),
                };

                // Build the capture operands
                let mut capture_operands = Vec::new();
                for cap in captures {
                    if let Some(&local) = self.hir_to_local.get(&cap.def_id) {
                        let place = Place::from_local(local);
                        let cap_ty = Ty::from_hir(&cap.ty);
                        let operand = if *is_move || !cap_ty.is_copy() {
                            if cap.by_ref {
                                // Capture by reference
                                let ref_local = self.func.add_local(LocalDecl::new(
                                    None,
                                    Ty::Ref {
                                        mutable: false,
                                        inner: Box::new(cap_ty),
                                    },
                                    false,
                                    expr.span,
                                ));
                                self.push_statement(Statement::Assign {
                                    place: Place::from_local(ref_local),
                                    rvalue: Rvalue::Ref {
                                        mutable: false,
                                        place,
                                    },
                                    span: expr.span,
                                });
                                Operand::Move(Place::from_local(ref_local))
                            } else {
                                Operand::Move(place)
                            }
                        } else if cap.by_ref {
                            let ref_local = self.func.add_local(LocalDecl::new(
                                None,
                                Ty::Ref {
                                    mutable: false,
                                    inner: Box::new(cap_ty),
                                },
                                false,
                                expr.span,
                            ));
                            self.push_statement(Statement::Assign {
                                place: Place::from_local(ref_local),
                                rvalue: Rvalue::Ref {
                                    mutable: false,
                                    place,
                                },
                                span: expr.span,
                            });
                            Operand::Copy(Place::from_local(ref_local))
                        } else {
                            Operand::Copy(place)
                        };
                        capture_operands.push(operand);
                    }
                }

                // Construct the closure aggregate (captures)
                self.push_statement(Statement::Assign {
                    place: destination,
                    rvalue: Rvalue::Aggregate {
                        kind: AggregateKind::Closure(closure_id),
                        operands: capture_operands,
                    },
                    span: expr.span,
                });

                // Build a separate FunctionMIR for the closure body.
                // The function is named "closure_{id}" and takes:
                //   - env pointer (for captures) as first param
                //   - then the closure's own params
                let closure_return_ty = Ty::from_hir(return_ty);
                let closure_func_name = Symbol::intern(&format!("JouleClosure_{}_fn", closure_id));
                let mut closure_builder = MirBuilder::new(
                    FunctionId::new(closure_id),
                    closure_func_name,
                    closure_return_ty.clone(),
                    expr.span,
                );
                closure_builder.variant_index_map = self.variant_index_map.clone();

                // Return place type
                closure_builder.func.locals[0].ty = closure_return_ty;

                // First param: env pointer — use Named type so codegen can resolve fields
                let env_type_name = Symbol::intern(&format!("JouleClosure_{}_env", closure_id));
                let env_local = closure_builder.func.add_local(LocalDecl::new(
                    Some(Symbol::intern("_env")),
                    Ty::RawPtr {
                        mutable: false,
                        inner: Box::new(Ty::Named {
                            def_id: HirId::new(closure_id),
                            name: env_type_name,
                        }),
                    },
                    false,
                    expr.span,
                ));
                closure_builder.func.params.push(env_local);

                // Add closure parameters
                for param in params {
                    let param_ty = Ty::from_hir(&param.ty);
                    let param_name = if let hir::Pattern::Ident { name, .. } = &param.pattern {
                        Some(*name)
                    } else {
                        None
                    };
                    let local = closure_builder
                        .func
                        .add_local(LocalDecl::new(param_name, param_ty, false, param.span));
                    closure_builder.func.params.push(local);
                    if let hir::Pattern::Ident { id, .. } = &param.pattern {
                        closure_builder.hir_to_local.insert(*id, local);
                    }
                }

                // Map captured variables to env struct field accesses
                for cap in captures.iter() {
                    let cap_ty = Ty::from_hir(&cap.ty);
                    let cap_local = closure_builder.func.add_local(LocalDecl::new(
                        Some(cap.name),
                        cap_ty,
                        true,
                        expr.span,
                    ));
                    closure_builder.hir_to_local.insert(cap.def_id, cap_local);
                }

                // Create entry block and build body
                let entry = closure_builder.new_block();
                closure_builder.current_block = Some(entry);

                // For captures, emit assignments from env fields at the start of the body.
                // The env param is a pointer, so we need Deref before Field access:
                //   cap_local = (*env_local).field_i
                for (i, cap) in captures.iter().enumerate() {
                    if let Some(&cap_local) = closure_builder.hir_to_local.get(&cap.def_id) {
                        closure_builder.push_statement(Statement::Assign {
                            place: Place::from_local(cap_local),
                            rvalue: Rvalue::Use(Operand::Copy(Place {
                                local: env_local,
                                projection: vec![
                                    PlaceElem::Deref,
                                    PlaceElem::Field(FieldIdx::new(i as u32)),
                                ],
                            })),
                            span: expr.span,
                        });
                    }
                }

                // Build the closure body expression
                closure_builder.build_expr_into(body, Place::return_place());
                closure_builder.ensure_return();

                // Collect any nested closures from the closure builder
                let nested = closure_builder.pending_closures;
                self.pending_closures.push(closure_builder.func);
                self.pending_closures.extend(nested);

                let _ = closure_ty;
            }
        }
    }

    /// Build a select expression
    fn build_select(
        &mut self,
        arms: &[hir::HirSelectArm],
        _biased: bool,
        destination: Place,
        span: Span,
    ) {
        use crate::{ChannelOp, SelectArm};

        let mut mir_arms = Vec::new();
        let mut arm_blocks = Vec::new();
        let join_block = self.new_block();

        // Create blocks and operations for each arm
        for arm in arms {
            let arm_block = self.new_block();
            arm_blocks.push((arm_block, arm));

            let operation = match &arm.operation {
                hir::HirSelectOperation::Recv { channel } => {
                    // Build channel expression into a temp
                    let chan_temp = self.new_temp(Ty::from_hir(&channel.ty), channel.span);
                    self.build_expr_into(channel, Place::from_local(chan_temp));
                    ChannelOp::Recv {
                        channel: Operand::Copy(Place::from_local(chan_temp)),
                    }
                }
                hir::HirSelectOperation::Send { channel, value } => {
                    let chan_temp = self.new_temp(Ty::from_hir(&channel.ty), channel.span);
                    self.build_expr_into(channel, Place::from_local(chan_temp));
                    let val_temp = self.new_temp(Ty::from_hir(&value.ty), value.span);
                    self.build_expr_into(value, Place::from_local(val_temp));
                    ChannelOp::Send {
                        channel: Operand::Copy(Place::from_local(chan_temp)),
                        value: Operand::Copy(Place::from_local(val_temp)),
                    }
                }
                hir::HirSelectOperation::Timeout { duration: _ } => {
                    // For now, use a default timeout
                    ChannelOp::Timeout {
                        duration_ns: 1_000_000_000, // 1 second default
                    }
                }
            };

            mir_arms.push(SelectArm {
                operation,
                target: arm_block,
            });
        }

        // Create temp for selected arm index
        let selected_arm = self.new_temp(Ty::Uint(UintTy::U32), span);

        // Emit select terminator
        self.set_terminator(Terminator::Select {
            arms: mir_arms,
            default: None,
            destination: destination.clone(),
            selected_arm: Place::from_local(selected_arm),
            span,
        });

        // Build arm bodies
        for (arm_block, arm) in arm_blocks {
            self.current_block = Some(arm_block);
            self.build_expr_into(&arm.body, destination.clone());
            if self.current_block.is_some() {
                self.set_terminator(Terminator::Goto {
                    target: join_block,
                    span: arm.span,
                });
            }
        }

        // Continue in join block
        self.current_block = Some(join_block);
    }

    /// Build an if expression
    fn build_if(
        &mut self,
        condition: &hir::Expr,
        then_block: &hir::Block,
        else_block: Option<&hir::Expr>,
        destination: Place,
        span: Span,
    ) {
        // Evaluate condition
        let cond_temp = self.new_temp(Ty::Bool, condition.span);
        self.build_expr_into(condition, Place::from_local(cond_temp));

        // Create blocks
        let then_bb = self.new_block();
        let else_bb = self.new_block();
        let join_bb = self.new_block();

        // Branch on condition
        self.set_terminator(Terminator::SwitchInt {
            discriminant: Operand::Copy(Place::from_local(cond_temp)),
            targets: SwitchTargets::if_else(then_bb, else_bb),
            span,
        });

        // Build then block
        self.current_block = Some(then_bb);
        self.build_block_expr(then_block, destination.clone());
        if self.current_block.is_some() {
            self.set_terminator(Terminator::Goto {
                target: join_bb,
                span,
            });
        }

        // Build else block
        self.current_block = Some(else_bb);
        if let Some(else_expr) = else_block {
            self.build_expr_into(else_expr, destination);
        } else {
            // No else block, assign unit
            self.push_statement(Statement::Assign {
                place: destination,
                rvalue: Rvalue::Aggregate {
                    kind: AggregateKind::Tuple,
                    operands: vec![],
                },
                span,
            });
        }
        if self.current_block.is_some() {
            self.set_terminator(Terminator::Goto {
                target: join_bb,
                span,
            });
        }

        // Continue in join block
        self.current_block = Some(join_bb);
    }

    /// Convert an HIR pattern to a MIR match lowering pattern
    fn hir_pattern_to_mir_pat(&self, pattern: &hir::Pattern) -> crate::match_lowering::Pat {
        match pattern {
            hir::Pattern::Wildcard { .. } => crate::match_lowering::Pat::Wild,
            hir::Pattern::Ident { name, .. } => crate::match_lowering::Pat::Bind {
                name: name.as_str().to_string(),
                inner: None,
            },
            hir::Pattern::Tuple { patterns, .. } => {
                let fields: Vec<_> = patterns
                    .iter()
                    .map(|p| self.hir_pattern_to_mir_pat(p))
                    .collect();
                crate::match_lowering::Pat::Ctor {
                    ctor: crate::match_lowering::CtorKind::Tuple(fields.len()),
                    fields,
                }
            }
            hir::Pattern::Struct { def_id, fields, .. } => {
                let field_pats: Vec<_> = fields
                    .iter()
                    .map(|f| self.hir_pattern_to_mir_pat(&f.pattern))
                    .collect();
                crate::match_lowering::Pat::Ctor {
                    ctor: crate::match_lowering::CtorKind::Struct {
                        struct_id: def_id.0,
                    },
                    fields: field_pats,
                }
            }
            hir::Pattern::Variant {
                enum_name,
                variant_name,
                ..
            } => {
                // Map variant name to discriminant value
                // Result: Ok=1 (is_ok=true), Err=0 (is_ok=false)
                // Option: Some=1 (is_some=true), None=0 (is_some=false)
                // Other enums: use variant index from enum definitions
                let variant_str = variant_name.as_str();
                let enum_str = enum_name.as_str();
                let disc = match variant_str.as_str() {
                    "Ok" | "Some" => 1u128,
                    "Err" | "None" => 0u128,
                    _ => {
                        // Look up actual variant index from enum definitions
                        self.variant_index_map
                            .get(&(enum_str.to_string(), variant_str.to_string()))
                            .copied()
                            .unwrap_or(0u128)
                    }
                };
                crate::match_lowering::Pat::Literal(crate::match_lowering::LitPat::Int(
                    disc as i128,
                ))
            }
            hir::Pattern::Literal { value, .. } => {
                // Strings can't be SwitchInt discriminants — treat as wildcard
                if matches!(value, hir::LitValue::String(_)) {
                    return crate::match_lowering::Pat::Wild;
                }
                let disc = match value {
                    hir::LitValue::Int(n) => *n,
                    hir::LitValue::Char(c) => *c as i128,
                    hir::LitValue::Bool(b) => {
                        if *b {
                            1
                        } else {
                            0
                        }
                    }
                    hir::LitValue::String(_) => unreachable!(),
                };
                crate::match_lowering::Pat::Literal(crate::match_lowering::LitPat::Int(disc))
            }
            hir::Pattern::Or { patterns, .. } => {
                let pats = patterns
                    .iter()
                    .map(|p| self.hir_pattern_to_mir_pat(p))
                    .collect();
                crate::match_lowering::Pat::Or(pats)
            }
            hir::Pattern::Range {
                lo, hi, inclusive, ..
            } => {
                let lo_val = match lo {
                    hir::LitValue::Int(n) => Some(*n),
                    hir::LitValue::Char(c) => Some(*c as i128),
                    _ => None,
                };
                let hi_val = match hi {
                    hir::LitValue::Int(n) => Some(*n),
                    hir::LitValue::Char(c) => Some(*c as i128),
                    _ => None,
                };
                crate::match_lowering::Pat::Range {
                    lo: lo_val,
                    hi: hi_val,
                    inclusive: *inclusive,
                }
            }
        }
    }

    /// Build a place from an expression
    fn build_place(&mut self, expr: &hir::Expr) -> Place {
        match &expr.kind {
            hir::ExprKind::Var { def_id, .. } => {
                if let Some(&local) = self.hir_to_local.get(def_id) {
                    Place::from_local(local)
                } else {
                    // Fallback: create a temporary
                    let temp = self.new_temp(Ty::from_hir(&expr.ty), expr.span);
                    Place::from_local(temp)
                }
            }

            hir::ExprKind::Deref { expr: inner } => {
                let inner_place = self.build_place(inner);
                inner_place.deref()
            }

            hir::ExprKind::Field {
                expr: inner,
                field_idx,
                ..
            } => {
                let inner_place = self.build_place(inner);
                inner_place.field(FieldIdx::new(*field_idx as u32))
            }

            hir::ExprKind::Index { expr: inner, index } => {
                let inner_place = self.build_place(inner);
                // Build index into a local
                let index_local = self.new_temp(Ty::from_hir(&index.ty), index.span);
                self.build_expr_into(index, Place::from_local(index_local));
                inner_place.index(index_local)
            }

            hir::ExprKind::MultiDimIndex { .. } => {
                // Multi-dim indexing uses function calls (_get/_set),
                // so it cannot produce a Place directly.
                // Evaluate into a temporary for read access.
                let temp = self.new_temp(Ty::from_hir(&expr.ty), expr.span);
                self.build_expr_into(expr, Place::from_local(temp));
                Place::from_local(temp)
            }

            _ => {
                // For other expressions, evaluate into a temporary
                let temp = self.new_temp(Ty::from_hir(&expr.ty), expr.span);
                self.build_expr_into(expr, Place::from_local(temp));
                Place::from_local(temp)
            }
        }
    }

    /// Determine the kind of cast
    fn determine_cast_kind(&self, from: &hir::Ty, to: &hir::Ty) -> crate::CastKind {
        use crate::CastKind;

        match (from, to) {
            (hir::Ty::Int(_) | hir::Ty::Uint(_), hir::Ty::Int(_) | hir::Ty::Uint(_)) => {
                CastKind::IntToInt
            }
            (hir::Ty::Float(_), hir::Ty::Float(_)) => CastKind::FloatToFloat,
            (hir::Ty::Int(_) | hir::Ty::Uint(_), hir::Ty::Float(_)) => CastKind::IntToFloat,
            (hir::Ty::Float(_), hir::Ty::Int(_) | hir::Ty::Uint(_)) => CastKind::FloatToInt,
            (hir::Ty::Ref { .. }, hir::Ty::Ref { .. }) => CastKind::PtrToPtr,
            _ => CastKind::IntToInt, // Default fallback
        }
    }
}

/// Get the type name prefix for an impl block's self type
fn get_impl_type_prefix(ty: &hir::Ty) -> String {
    match ty {
        hir::Ty::Named { name, .. } => {
            let s = name.as_str();
            // Handle Self type - should be resolved by context but fallback gracefully
            if s == "Self" {
                "Self".to_string() // Will be resolved later if possible
            } else {
                s.to_string()
            }
        }
        hir::Ty::Generic { name, args, .. } => {
            let base = name.as_str();
            if args.is_empty() {
                base.to_string()
            } else {
                let arg_strs: Vec<String> = args.iter().map(get_impl_type_prefix).collect();
                format!("{}<{}>", base, arg_strs.join(", "))
            }
        }
        hir::Ty::TypeParam { name, .. } => name.as_str().to_string(),
        hir::Ty::Int(int_ty) => format!("{:?}", int_ty).to_lowercase(),
        hir::Ty::Uint(uint_ty) => format!("{:?}", uint_ty).to_lowercase(),
        hir::Ty::Float(float_ty) => format!("{:?}", float_ty).to_lowercase(),
        hir::Ty::Bool => "bool".to_string(),
        hir::Ty::Char => "char".to_string(),
        hir::Ty::String => "JouleString".to_string(), // Match C typedef
        hir::Ty::Unit => "unit".to_string(),
        hir::Ty::Never => "never".to_string(),
        hir::Ty::Tuple(tys) => {
            let arg_strs: Vec<String> = tys.iter().map(get_impl_type_prefix).collect();
            format!("({})", arg_strs.join(", "))
        }
        // For method receivers like &self, unwrap to get the actual type
        hir::Ty::Ref { inner, .. } => get_impl_type_prefix(inner),
        hir::Ty::Array { element, size } => {
            format!("[{}; {}]", get_impl_type_prefix(element), size)
        }
        hir::Ty::Slice { element } => {
            format!("[{}]", get_impl_type_prefix(element))
        }
        hir::Ty::Function { params, return_ty } => {
            let param_strs: Vec<String> = params.iter().map(get_impl_type_prefix).collect();
            format!(
                "fn({}) -> {}",
                param_strs.join(", "),
                get_impl_type_prefix(return_ty)
            )
        }
        hir::Ty::Infer(_) => "infer".to_string(),
        hir::Ty::Error => "void".to_string(), // Fallback for unresolved types
        hir::Ty::Future { result_ty } => format!("Future<{}>", get_impl_type_prefix(result_ty)),
        hir::Ty::Task { result_ty } => format!("Task<{}>", get_impl_type_prefix(result_ty)),
        hir::Ty::TaskGroup => "TaskGroup".to_string(),
        hir::Ty::Channel { element_ty } => format!("Channel<{}>", get_impl_type_prefix(element_ty)),
        hir::Ty::Sender { element_ty } => format!("Sender<{}>", get_impl_type_prefix(element_ty)),
        hir::Ty::Receiver { element_ty } => {
            format!("Receiver<{}>", get_impl_type_prefix(element_ty))
        }
        hir::Ty::TraitObject { trait_name } => {
            format!("dyn_{}", trait_name.as_str())
        }
        hir::Ty::Closure {
            id,
            params,
            return_ty,
            ..
        } => {
            let param_strs: Vec<String> = params.iter().map(get_impl_type_prefix).collect();
            format!(
                "Closure_{}({}) -> {}",
                id.0,
                param_strs.join(", "),
                get_impl_type_prefix(return_ty)
            )
        }
        hir::Ty::Union { variants } => {
            let var_strs: Vec<String> = variants.iter().map(get_impl_type_prefix).collect();
            var_strs.join("_or_")
        }
        hir::Ty::Opaque { name, .. } => name.as_str().to_string(),
        hir::Ty::NDArray { element, rank } => {
            format!("NDArray[{}; {}]", get_impl_type_prefix(element), rank)
        }
        hir::Ty::NDView { element, rank } => {
            format!("NDView[{}; {}]", get_impl_type_prefix(element), rank)
        }
        hir::Ty::CowArray { element, rank } => {
            format!("CowArray[{}; {}]", get_impl_type_prefix(element), rank)
        }
        hir::Ty::DynArray { element } => {
            format!("DynArray[{}]", get_impl_type_prefix(element))
        }
        hir::Ty::SmallVec { element, capacity } => {
            format!("SmallVec[{}; {}]", get_impl_type_prefix(element), capacity)
        }
        hir::Ty::Simd { element, lanes } => {
            format!("Simd[{}; {}]", get_impl_type_prefix(element), lanes)
        }
    }
}

/// Get the C-compatible type prefix for an NDArray MIR type.
///
/// Used to generate function names like `JouleNDArray_double_2_get`.
fn ndarray_type_prefix(ty: &crate::Ty) -> String {
    match ty {
        crate::Ty::NDArray { element, rank } => {
            let elem = mir_ty_to_c_ident(element);
            format!("JouleNDArray_{elem}_{rank}")
        }
        crate::Ty::NDView { element, rank } => {
            let elem = mir_ty_to_c_ident(element);
            format!("JouleNDView_{elem}_{rank}")
        }
        crate::Ty::CowArray { element, rank } => {
            let elem = mir_ty_to_c_ident(element);
            format!("JouleCowArray_{elem}_{rank}")
        }
        crate::Ty::DynArray { element } => {
            let elem = mir_ty_to_c_ident(element);
            format!("JouleDynArray_{elem}")
        }
        crate::Ty::SmallVec { element, capacity } => {
            let elem = mir_ty_to_c_ident(element);
            format!("JouleSmallVec_{elem}_{capacity}")
        }
        crate::Ty::Simd { element, lanes } => {
            let elem = mir_ty_to_c_ident(element);
            format!("JouleSimd_{elem}_{lanes}")
        }
        _ => "ndarray_unknown".to_string(),
    }
}

/// Convert a MIR type to a C-compatible identifier fragment (for ndarray naming).
fn mir_ty_to_c_ident(ty: &crate::Ty) -> String {
    match ty {
        crate::Ty::Bool => "bool".to_string(),
        crate::Ty::Char => "u32".to_string(),
        crate::Ty::Int(crate::IntTy::I8) => "i8".to_string(),
        crate::Ty::Int(crate::IntTy::I16) => "i16".to_string(),
        crate::Ty::Int(crate::IntTy::I32) => "i32".to_string(),
        crate::Ty::Int(crate::IntTy::I64) => "i64".to_string(),
        crate::Ty::Int(crate::IntTy::Isize) => "isize".to_string(),
        crate::Ty::Uint(crate::UintTy::U8) => "u8".to_string(),
        crate::Ty::Uint(crate::UintTy::U16) => "u16".to_string(),
        crate::Ty::Uint(crate::UintTy::U32) => "u32".to_string(),
        crate::Ty::Uint(crate::UintTy::U64) => "u64".to_string(),
        crate::Ty::Uint(crate::UintTy::Usize) => "usize".to_string(),
        crate::Ty::Float(crate::FloatTy::F16) => "JouleF16".to_string(),
        crate::Ty::Float(crate::FloatTy::BF16) => "JouleBF16".to_string(),
        crate::Ty::Float(crate::FloatTy::F32) => "float".to_string(),
        crate::Ty::Float(crate::FloatTy::F64) => "double".to_string(),
        _ => "void".to_string(),
    }
}

/// Build MIR for an entire HIR module
pub fn build_mir(hir: &hir::Hir) -> crate::MirContext {
    let mut ctx = crate::MirContext::new();

    // Precompute variant index map from all enum definitions
    let mut variant_index_map: HashMap<(String, String), u128> = HashMap::new();
    for item in &hir.items {
        if let hir::Item::Enum(e) = item {
            let enum_name = e.name.as_str().to_string();
            for (idx, variant) in e.variants.iter().enumerate() {
                let variant_name = variant.name.as_str().to_string();
                variant_index_map.insert((enum_name.clone(), variant_name), idx as u128);
            }
        }
    }

    for item in &hir.items {
        match item {
            hir::Item::Function(func) => {
                if func.is_extern {
                    // Extern functions have no body — record them so the C emitter
                    // emits only a forward declaration (no stub).
                    ctx.extern_fns.push(func.clone());
                } else {
                    let (mir_func, closures) =
                        MirBuilder::build_function_with_enums(func, &variant_index_map);
                    ctx.add_function(mir_func);
                    for closure_func in closures {
                        ctx.add_function(closure_func);
                    }
                }
            }
            hir::Item::Struct(s) => {
                ctx.structs.push(s.clone());
            }
            hir::Item::Enum(e) => {
                ctx.enums.push(e.clone());
            }
            hir::Item::Trait(t) => {
                ctx.traits.push(t.clone());
            }
            hir::Item::Impl(imp) => {
                // Get the type name for prefixing method names
                let type_prefix = get_impl_type_prefix(&imp.ty);

                // Build MIR for each method in the impl block
                for impl_item in &imp.items {
                    match impl_item {
                        hir::ImplItem::Function(func) => {
                            let (mut mir_func, closures) =
                                MirBuilder::build_function_with_enums(func, &variant_index_map);
                            // Prefix the function name with the type name for C compatibility
                            let qualified_name = format!("{}::{}", type_prefix, func.name.as_str());
                            mir_func.name = Symbol::intern(&qualified_name);
                            ctx.add_function(mir_func);
                            for closure_func in closures {
                                ctx.add_function(closure_func);
                            }
                        }
                    }
                }
                ctx.impls.push(imp.clone());
            }
            hir::Item::Const(c) => {
                ctx.consts.push(c.clone());
            }
            hir::Item::Static(s) => {
                ctx.statics.push(s.clone());
            }
            // Effect and Supervisor declarations are metadata-only items.
            // Their runtime support is compiled by the C codegen from the
            // declaration data, not through MIR function bodies.
            hir::Item::Effect(_) | hir::Item::Supervisor(_) => {}
        }
    }

    // Copy type aliases from HIR to MIR
    for (name, ty) in &hir.type_aliases {
        ctx.type_aliases
            .insert(name.as_str().to_string(), ty.clone());
    }

    ctx
}

#[cfg(test)]
mod tests {
    use super::*;
    use joule_hir::IntTy;

    #[test]
    fn test_mir_builder_creation() {
        let builder = MirBuilder::new(
            FunctionId::new(0),
            Symbol::from_u32(0),
            Ty::Unit,
            Span::dummy(),
        );
        assert_eq!(builder.func.locals.len(), 1); // Return place
        assert_eq!(builder.func.basic_blocks.len(), 0);
    }

    #[test]
    fn test_new_local() {
        let mut builder = MirBuilder::new(
            FunctionId::new(0),
            Symbol::from_u32(0),
            Ty::Unit,
            Span::dummy(),
        );

        let local = builder.new_local(Some(hir::Ty::Int(IntTy::I32)), Span::dummy(), false);
        assert_eq!(local, Local::new(1));
        assert_eq!(builder.func.locals.len(), 2);
    }

    #[test]
    fn test_new_block() {
        let mut builder = MirBuilder::new(
            FunctionId::new(0),
            Symbol::from_u32(0),
            Ty::Unit,
            Span::dummy(),
        );

        let block_id = builder.new_block();
        assert_eq!(block_id, BasicBlockId::new(0));
        assert_eq!(builder.func.basic_blocks.len(), 1);
    }
}