joule_mir/

match_lowering.rs

//! Match expression lowering for Joule MIR
//!
//! Converts match expressions into decision trees in MIR.
//! Uses the classic pattern matching compilation algorithm.

use crate::{
    BasicBlock, BasicBlockId, FieldIdx, FunctionMIR, IntTy, Local, LocalDecl, Operand, Place,
    Rvalue, Statement, SwitchTargets, Terminator, Ty,
};
use joule_common::Span;

/// A pattern in the pattern matrix
#[derive(Debug, Clone)]
pub enum Pat {
    /// Wildcard pattern
    Wild,
    /// Binding pattern
    Bind {
        name: String,
        inner: Option<Box<Pat>>,
    },
    /// Literal pattern
    Literal(LitPat),
    /// Constructor pattern (enum variant, struct)
    Ctor { ctor: CtorKind, fields: Vec<Pat> },
    /// Or-pattern
    Or(Vec<Pat>),
    /// Range pattern
    Range {
        lo: Option<i128>,
        hi: Option<i128>,
        inclusive: bool,
    },
}

impl Pat {
    /// Check if this pattern is a wildcard or binding (always matches)
    pub fn is_wildcard(&self) -> bool {
        matches!(self, Pat::Wild | Pat::Bind { .. })
    }

    /// Get the fields of this pattern if it's a constructor
    pub fn fields(&self) -> Option<&[Pat]> {
        match self {
            Pat::Ctor { fields, .. } => Some(fields),
            _ => None,
        }
    }

    /// Check if this pattern binds a name
    pub fn binding_name(&self) -> Option<&str> {
        match self {
            Pat::Bind { name, .. } => Some(name),
            _ => None,
        }
    }
}

/// Literal patterns
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum LitPat {
    Int(i128),
    Bool(bool),
    Char(char),
    Str(String),
}

impl LitPat {
    /// Convert to a discriminant value for switch
    pub fn to_discriminant(&self) -> u128 {
        match self {
            LitPat::Int(n) => *n as u128,
            LitPat::Bool(b) => {
                if *b {
                    1
                } else {
                    0
                }
            }
            LitPat::Char(c) => *c as u128,
            LitPat::Str(_) => 0, // String comparison needs special handling
        }
    }
}

/// Constructor kinds
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum CtorKind {
    /// Enum variant
    Variant { enum_id: u32, variant_idx: u32 },
    /// Struct
    Struct { struct_id: u32 },
    /// Tuple
    Tuple(usize),
    /// Array
    Array(usize),
    /// Slice
    Slice { min_len: usize, has_rest: bool },
    /// Box
    Box,
    /// Reference
    Ref { mutable: bool },
}

impl CtorKind {
    /// Get the arity (number of fields) of this constructor
    pub fn arity(&self) -> usize {
        match self {
            CtorKind::Variant { .. } => 0, // Would look up actual arity from type info
            CtorKind::Struct { .. } => 0,  // Would look up actual arity from type info
            CtorKind::Tuple(n) => *n,
            CtorKind::Array(n) => *n,
            CtorKind::Slice { min_len, .. } => *min_len,
            CtorKind::Box => 1,
            CtorKind::Ref { .. } => 1,
        }
    }

    /// Get the discriminant value for this constructor
    pub fn discriminant(&self) -> Option<u128> {
        match self {
            CtorKind::Variant { variant_idx, .. } => Some(*variant_idx as u128),
            _ => None,
        }
    }
}

/// A match arm for lowering
#[derive(Debug, Clone)]
pub struct MatchArm {
    /// The pattern
    pub pattern: Pat,
    /// Guard expression (if any) - represented as a local containing the guard result
    pub guard: Option<Local>,
    /// Body block ID
    pub body: BasicBlockId,
    /// Bindings to be set before entering the body
    pub bindings: Vec<(String, Local)>,
    /// Span
    pub span: Span,
}

/// Match lowering context
pub struct MatchLowering<'a> {
    /// The function we're lowering into
    func: &'a mut FunctionMIR,
    /// Type information for the scrutinee
    _scrutinee_ty: Ty,
    /// Generated blocks (to be merged into function)
    new_blocks: Vec<BasicBlock>,
}

/// A lowered basic block (for return value)
#[derive(Debug)]
pub struct LoweredBlock {
    pub id: BasicBlockId,
    pub statements: Vec<Statement>,
    pub terminator: Terminator,
}

impl<'a> MatchLowering<'a> {
    /// Create a new match lowering context
    pub fn new(func: &'a mut FunctionMIR, scrutinee_ty: Ty) -> Self {
        Self {
            func,
            _scrutinee_ty: scrutinee_ty,
            new_blocks: Vec::new(),
        }
    }

    /// Lower a match expression
    ///
    /// Returns the entry block ID for the match
    pub fn lower_match(
        &mut self,
        scrutinee: Place,
        arms: &[MatchArm],
        result_place: Place,
        join_block: BasicBlockId,
        span: Span,
    ) -> BasicBlockId {
        // Build the pattern matrix
        let matrix = self.build_matrix(arms);

        // Compile the matrix into a decision tree
        let entry_block = self.compile_matrix(
            matrix,
            vec![scrutinee],
            arms,
            result_place,
            join_block,
            span,
        );

        // Move new blocks into the function
        for block in std::mem::take(&mut self.new_blocks) {
            self.func.basic_blocks.push(block);
        }

        entry_block
    }

    /// Build the pattern matrix from match arms
    fn build_matrix(&self, arms: &[MatchArm]) -> PatternMatrix {
        let rows: Vec<_> = arms
            .iter()
            .enumerate()
            .map(|(i, arm)| PatternRow {
                patterns: vec![arm.pattern.clone()],
                guard: arm.guard,
                arm_index: i,
            })
            .collect();

        PatternMatrix { rows }
    }

    /// Compile a pattern matrix into decision tree
    fn compile_matrix(
        &mut self,
        matrix: PatternMatrix,
        scrutinees: Vec<Place>,
        arms: &[MatchArm],
        result_place: Place,
        join_block: BasicBlockId,
        span: Span,
    ) -> BasicBlockId {
        // Base case: empty matrix (unreachable)
        if matrix.rows.is_empty() {
            let block_id = self.new_block_id();
            self.new_blocks
                .push(BasicBlock::new(Terminator::Unreachable { span }));
            return block_id;
        }

        // Base case: all patterns in first column are wildcards
        if matrix.all_wildcards() {
            // First row matches - emit bindings and jump to body
            let first_row = &matrix.rows[0];
            let arm = &arms[first_row.arm_index];

            // Check guard if present
            if let Some(guard_local) = first_row.guard {
                return self.compile_with_guard(
                    guard_local,
                    arm,
                    matrix.rows[1..].to_vec(),
                    scrutinees,
                    arms,
                    result_place,
                    join_block,
                    span,
                );
            }

            // No guard - just emit bindings and jump to body
            let block_id = self.new_block_id();
            let statements = self.emit_bindings(&arm.bindings, &scrutinees, span);

            self.new_blocks.push(BasicBlock {
                statements,
                terminator: Terminator::Goto {
                    target: arm.body,
                    span,
                },
            });

            return block_id;
        }

        // Find the best column to split on
        let col = self.select_column(&matrix);

        // No scrutinee for this column (shouldn't happen)
        if col >= scrutinees.len() {
            let block_id = self.new_block_id();
            self.new_blocks
                .push(BasicBlock::new(Terminator::Unreachable { span }));
            return block_id;
        }

        let scrutinee = scrutinees[col].clone();

        // Get the constructors used in this column
        let ctors = self.collect_constructors(&matrix, col);

        // If no constructors, all are wildcards - move to next column
        if ctors.is_empty() {
            let reduced = matrix.remove_column(col);
            let mut new_scrutinees = scrutinees.clone();
            new_scrutinees.remove(col);
            return self.compile_matrix(
                reduced,
                new_scrutinees,
                arms,
                result_place,
                join_block,
                span,
            );
        }

        // Check if we have literal patterns
        let literals = self.collect_literals(&matrix, col);
        if !literals.is_empty() {
            return self.compile_literal_switch(
                matrix,
                col,
                scrutinee,
                scrutinees,
                arms,
                result_place,
                join_block,
                span,
            );
        }

        // Create a switch on the constructor discriminant
        self.compile_ctor_switch(
            matrix,
            col,
            scrutinee,
            scrutinees,
            arms,
            result_place,
            join_block,
            span,
            &ctors,
        )
    }

    /// Compile with a guard check
    fn compile_with_guard(
        &mut self,
        guard_local: Local,
        arm: &MatchArm,
        remaining_rows: Vec<PatternRow>,
        scrutinees: Vec<Place>,
        arms: &[MatchArm],
        result_place: Place,
        join_block: BasicBlockId,
        span: Span,
    ) -> BasicBlockId {
        let guard_block = self.new_block_id();
        let body_block = arm.body;

        // Create else branch for when guard fails
        let else_matrix = PatternMatrix {
            rows: remaining_rows,
        };
        let else_block = self.compile_matrix(
            else_matrix,
            scrutinees.clone(),
            arms,
            result_place.clone(),
            join_block,
            span,
        );

        // Emit the guard check
        let statements = self.emit_bindings(&arm.bindings, &scrutinees, span);

        self.new_blocks.push(BasicBlock {
            statements,
            terminator: Terminator::SwitchInt {
                discriminant: Operand::Copy(Place::from_local(guard_local)),
                targets: SwitchTargets {
                    branches: vec![(1, body_block)], // true -> body
                    otherwise: else_block,           // false -> next pattern
                },
                span,
            },
        });

        guard_block
    }

    /// Compile a switch on literal values
    fn compile_literal_switch(
        &mut self,
        matrix: PatternMatrix,
        col: usize,
        scrutinee: Place,
        scrutinees: Vec<Place>,
        arms: &[MatchArm],
        result_place: Place,
        join_block: BasicBlockId,
        span: Span,
    ) -> BasicBlockId {
        let literals = self.collect_literals(&matrix, col);
        let switch_block = self.new_block_id();

        let mut branches = Vec::new();

        for lit in &literals {
            // Specialize matrix for this literal
            let specialized = matrix.specialize_literal(col, lit);
            let mut new_scrutinees = scrutinees.clone();
            new_scrutinees.remove(col);

            let case_block = self.compile_matrix(
                specialized,
                new_scrutinees,
                arms,
                result_place.clone(),
                join_block,
                span,
            );

            branches.push((lit.to_discriminant(), case_block));
        }

        // Default case (wildcard rows)
        let default_matrix = matrix.default(col);
        let mut default_scrutinees = scrutinees.clone();
        default_scrutinees.remove(col);

        let default_block = if default_matrix.rows.is_empty() {
            let unreachable_block = self.new_block_id();
            self.new_blocks
                .push(BasicBlock::new(Terminator::Unreachable { span }));
            unreachable_block
        } else {
            self.compile_matrix(
                default_matrix,
                default_scrutinees,
                arms,
                result_place,
                join_block,
                span,
            )
        };

        self.new_blocks.push(BasicBlock {
            statements: vec![],
            terminator: Terminator::SwitchInt {
                discriminant: Operand::Copy(scrutinee),
                targets: SwitchTargets {
                    branches,
                    otherwise: default_block,
                },
                span,
            },
        });

        switch_block
    }

    /// Compile a switch on constructor discriminant
    fn compile_ctor_switch(
        &mut self,
        matrix: PatternMatrix,
        col: usize,
        scrutinee: Place,
        scrutinees: Vec<Place>,
        arms: &[MatchArm],
        result_place: Place,
        join_block: BasicBlockId,
        span: Span,
        ctors: &[CtorKind],
    ) -> BasicBlockId {
        let switch_block = self.new_block_id();
        let mut branches = Vec::new();

        for ctor in ctors {
            // Specialize matrix for this constructor
            let specialized = matrix.specialize(col, ctor);

            // Create places for constructor fields
            let mut new_scrutinees = scrutinees.clone();
            new_scrutinees.remove(col);

            // Add field places
            let arity = ctor.arity();
            for i in 0..arity {
                let field_place = scrutinee.clone().field(FieldIdx::new(i as u32));
                new_scrutinees.push(field_place);
            }

            let case_block = self.compile_matrix(
                specialized,
                new_scrutinees,
                arms,
                result_place.clone(),
                join_block,
                span,
            );

            if let Some(discr) = ctor.discriminant() {
                branches.push((discr, case_block));
            } else {
                // Single constructor (struct, tuple) - direct jump
                branches.push((0, case_block));
            }
        }

        // Default case for non-exhaustive matches
        let default_matrix = matrix.default(col);
        let mut default_scrutinees = scrutinees.clone();
        default_scrutinees.remove(col);

        let default_block = if default_matrix.rows.is_empty() {
            let unreachable_block = self.new_block_id();
            self.new_blocks
                .push(BasicBlock::new(Terminator::Unreachable { span }));
            unreachable_block
        } else {
            self.compile_matrix(
                default_matrix,
                default_scrutinees,
                arms,
                result_place,
                join_block,
                span,
            )
        };

        // If there's only one constructor and no discriminant, use Goto
        if ctors.len() == 1 && ctors[0].discriminant().is_none() {
            self.new_blocks.push(BasicBlock {
                statements: vec![],
                terminator: Terminator::Goto {
                    target: branches[0].1,
                    span,
                },
            });
        } else {
            // Get discriminant
            let discr_local = self.new_local(Ty::Int(IntTy::I32), span);
            let discr_place = Place::from_local(discr_local);

            self.new_blocks.push(BasicBlock {
                statements: vec![Statement::Assign {
                    place: discr_place.clone(),
                    rvalue: Rvalue::Discriminant { place: scrutinee },
                    span,
                }],
                terminator: Terminator::SwitchInt {
                    discriminant: Operand::Copy(discr_place),
                    targets: SwitchTargets {
                        branches,
                        otherwise: default_block,
                    },
                    span,
                },
            });
        }

        switch_block
    }

    /// Emit binding statements
    fn emit_bindings(
        &self,
        bindings: &[(String, Local)],
        _scrutinees: &[Place],
        span: Span,
    ) -> Vec<Statement> {
        // In a full implementation, this would copy/move values from scrutinees to locals
        // For now, we mark bindings as live
        bindings
            .iter()
            .map(|(_, local)| Statement::StorageLive {
                local: *local,
                span,
            })
            .collect()
    }

    /// Create a new block ID
    fn new_block_id(&self) -> BasicBlockId {
        BasicBlockId::new((self.func.basic_blocks.len() + self.new_blocks.len()) as u32)
    }

    /// Create a new local variable
    fn new_local(&mut self, ty: Ty, span: Span) -> Local {
        let local = Local::new(self.func.locals.len() as u32);
        self.func.locals.push(LocalDecl::new(None, ty, false, span));
        local
    }

    /// Select the best column to split on
    fn select_column(&self, matrix: &PatternMatrix) -> usize {
        // Heuristic: first column with a constructor
        for col in 0..matrix.width() {
            for row in &matrix.rows {
                if col < row.patterns.len() {
                    match &row.patterns[col] {
                        Pat::Wild | Pat::Bind { .. } => continue,
                        _ => return col,
                    }
                }
            }
        }
        0
    }

    /// Collect all constructors used in a column
    fn collect_constructors(&self, matrix: &PatternMatrix, col: usize) -> Vec<CtorKind> {
        let mut ctors = Vec::new();
        for row in &matrix.rows {
            if col < row.patterns.len() {
                if let Pat::Ctor { ctor, .. } = &row.patterns[col] {
                    if !ctors.contains(ctor) {
                        ctors.push(ctor.clone());
                    }
                }
            }
        }
        ctors
    }

    /// Collect all literals used in a column
    fn collect_literals(&self, matrix: &PatternMatrix, col: usize) -> Vec<LitPat> {
        let mut lits = Vec::new();
        for row in &matrix.rows {
            if col < row.patterns.len() {
                if let Pat::Literal(lit) = &row.patterns[col] {
                    if !lits.contains(lit) {
                        lits.push(lit.clone());
                    }
                }
            }
        }
        lits
    }
}

/// The pattern matrix used in match compilation
#[derive(Debug, Clone)]
pub struct PatternMatrix {
    pub rows: Vec<PatternRow>,
}

/// A row in the pattern matrix
#[derive(Debug, Clone)]
pub struct PatternRow {
    pub patterns: Vec<Pat>,
    pub guard: Option<Local>,
    pub arm_index: usize,
}

impl PatternMatrix {
    /// Get the width (number of columns) of the matrix
    pub fn width(&self) -> usize {
        self.rows.first().map_or(0, |r| r.patterns.len())
    }

    /// Check if all patterns in the first column are wildcards
    pub fn all_wildcards(&self) -> bool {
        self.rows.iter().all(|row| {
            row.patterns
                .first()
                .map(|p| p.is_wildcard())
                .unwrap_or(true)
        })
    }

    /// Remove a column from the matrix
    pub fn remove_column(&self, col: usize) -> PatternMatrix {
        let rows = self
            .rows
            .iter()
            .map(|row| PatternRow {
                patterns: row
                    .patterns
                    .iter()
                    .enumerate()
                    .filter(|(i, _)| *i != col)
                    .map(|(_, p)| p.clone())
                    .collect(),
                guard: row.guard,
                arm_index: row.arm_index,
            })
            .collect();
        PatternMatrix { rows }
    }

    /// Specialize the matrix for a constructor
    pub fn specialize(&self, col: usize, ctor: &CtorKind) -> PatternMatrix {
        let arity = ctor.arity();
        let rows = self
            .rows
            .iter()
            .filter_map(|row| {
                if col >= row.patterns.len() {
                    return None;
                }
                match &row.patterns[col] {
                    Pat::Wild | Pat::Bind { .. } => {
                        // Wildcard matches any constructor - expand with wildcards
                        let mut new_patterns: Vec<_> = (0..arity).map(|_| Pat::Wild).collect();
                        new_patterns.extend(
                            row.patterns
                                .iter()
                                .enumerate()
                                .filter(|(i, _)| *i != col)
                                .map(|(_, p)| p.clone()),
                        );
                        Some(PatternRow {
                            patterns: new_patterns,
                            guard: row.guard,
                            arm_index: row.arm_index,
                        })
                    }
                    Pat::Ctor {
                        ctor: row_ctor,
                        fields,
                    } if row_ctor == ctor => {
                        // Constructor matches - add fields
                        let mut new_patterns = fields.clone();
                        new_patterns.extend(
                            row.patterns
                                .iter()
                                .enumerate()
                                .filter(|(i, _)| *i != col)
                                .map(|(_, p)| p.clone()),
                        );
                        Some(PatternRow {
                            patterns: new_patterns,
                            guard: row.guard,
                            arm_index: row.arm_index,
                        })
                    }
                    Pat::Or(pats) => {
                        // Check if any alternative matches
                        for pat in pats {
                            match pat {
                                Pat::Wild | Pat::Bind { .. } => {
                                    let mut new_patterns: Vec<_> =
                                        (0..arity).map(|_| Pat::Wild).collect();
                                    new_patterns.extend(
                                        row.patterns
                                            .iter()
                                            .enumerate()
                                            .filter(|(i, _)| *i != col)
                                            .map(|(_, p)| p.clone()),
                                    );
                                    return Some(PatternRow {
                                        patterns: new_patterns,
                                        guard: row.guard,
                                        arm_index: row.arm_index,
                                    });
                                }
                                Pat::Ctor {
                                    ctor: pat_ctor,
                                    fields,
                                } if pat_ctor == ctor => {
                                    let mut new_patterns = fields.clone();
                                    new_patterns.extend(
                                        row.patterns
                                            .iter()
                                            .enumerate()
                                            .filter(|(i, _)| *i != col)
                                            .map(|(_, p)| p.clone()),
                                    );
                                    return Some(PatternRow {
                                        patterns: new_patterns,
                                        guard: row.guard,
                                        arm_index: row.arm_index,
                                    });
                                }
                                _ => {}
                            }
                        }
                        None
                    }
                    _ => None,
                }
            })
            .collect();
        PatternMatrix { rows }
    }

    /// Specialize the matrix for a literal
    pub fn specialize_literal(&self, col: usize, lit: &LitPat) -> PatternMatrix {
        let rows = self
            .rows
            .iter()
            .filter_map(|row| {
                if col >= row.patterns.len() {
                    return None;
                }
                match &row.patterns[col] {
                    Pat::Wild | Pat::Bind { .. } => {
                        // Wildcard matches any literal
                        let new_patterns: Vec<_> = row
                            .patterns
                            .iter()
                            .enumerate()
                            .filter(|(i, _)| *i != col)
                            .map(|(_, p)| p.clone())
                            .collect();
                        Some(PatternRow {
                            patterns: new_patterns,
                            guard: row.guard,
                            arm_index: row.arm_index,
                        })
                    }
                    Pat::Literal(row_lit) if row_lit == lit => {
                        // Literal matches
                        let new_patterns: Vec<_> = row
                            .patterns
                            .iter()
                            .enumerate()
                            .filter(|(i, _)| *i != col)
                            .map(|(_, p)| p.clone())
                            .collect();
                        Some(PatternRow {
                            patterns: new_patterns,
                            guard: row.guard,
                            arm_index: row.arm_index,
                        })
                    }
                    Pat::Or(pats) => {
                        // Check if any alternative matches
                        for pat in pats {
                            match pat {
                                Pat::Wild | Pat::Bind { .. } => {
                                    let new_patterns: Vec<_> = row
                                        .patterns
                                        .iter()
                                        .enumerate()
                                        .filter(|(i, _)| *i != col)
                                        .map(|(_, p)| p.clone())
                                        .collect();
                                    return Some(PatternRow {
                                        patterns: new_patterns,
                                        guard: row.guard,
                                        arm_index: row.arm_index,
                                    });
                                }
                                Pat::Literal(pat_lit) if pat_lit == lit => {
                                    let new_patterns: Vec<_> = row
                                        .patterns
                                        .iter()
                                        .enumerate()
                                        .filter(|(i, _)| *i != col)
                                        .map(|(_, p)| p.clone())
                                        .collect();
                                    return Some(PatternRow {
                                        patterns: new_patterns,
                                        guard: row.guard,
                                        arm_index: row.arm_index,
                                    });
                                }
                                _ => {}
                            }
                        }
                        None
                    }
                    _ => None,
                }
            })
            .collect();
        PatternMatrix { rows }
    }

    /// Get rows that don't match any specific constructor (default matrix)
    pub fn default(&self, col: usize) -> PatternMatrix {
        let rows = self
            .rows
            .iter()
            .filter_map(|row| {
                if col >= row.patterns.len() {
                    return Some(row.clone());
                }
                match &row.patterns[col] {
                    Pat::Wild | Pat::Bind { .. } => {
                        let new_patterns: Vec<_> = row
                            .patterns
                            .iter()
                            .enumerate()
                            .filter(|(i, _)| *i != col)
                            .map(|(_, p)| p.clone())
                            .collect();
                        Some(PatternRow {
                            patterns: new_patterns,
                            guard: row.guard,
                            arm_index: row.arm_index,
                        })
                    }
                    Pat::Or(pats) => {
                        // Include if any alternative is a wildcard
                        if pats.iter().any(|p| p.is_wildcard()) {
                            let new_patterns: Vec<_> = row
                                .patterns
                                .iter()
                                .enumerate()
                                .filter(|(i, _)| *i != col)
                                .map(|(_, p)| p.clone())
                                .collect();
                            Some(PatternRow {
                                patterns: new_patterns,
                                guard: row.guard,
                                arm_index: row.arm_index,
                            })
                        } else {
                            None
                        }
                    }
                    _ => None,
                }
            })
            .collect();
        PatternMatrix { rows }
    }
}

/// Helper to create a simple match for common cases
pub fn lower_simple_match(
    func: &mut FunctionMIR,
    scrutinee: Place,
    _scrutinee_ty: Ty,
    arms: Vec<(Pat, BasicBlockId)>,
    default_block: BasicBlockId,
    span: Span,
) -> BasicBlockId {
    let switch_block = BasicBlockId::new(func.basic_blocks.len() as u32);

    let mut branches = Vec::new();
    for (pat, target) in arms {
        match pat {
            Pat::Literal(lit) => {
                branches.push((lit.to_discriminant(), target));
            }
            Pat::Ctor { ctor, .. } => {
                if let Some(discr) = ctor.discriminant() {
                    branches.push((discr, target));
                }
            }
            _ => {}
        }
    }

    func.basic_blocks.push(BasicBlock {
        statements: vec![],
        terminator: Terminator::SwitchInt {
            discriminant: Operand::Copy(scrutinee),
            targets: SwitchTargets {
                branches,
                otherwise: default_block,
            },
            span,
        },
    });

    switch_block
}

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

    #[test]
    fn test_pattern_matrix_wildcards() {
        let matrix = PatternMatrix {
            rows: vec![
                PatternRow {
                    patterns: vec![Pat::Wild],
                    guard: None,
                    arm_index: 0,
                },
                PatternRow {
                    patterns: vec![Pat::Wild],
                    guard: None,
                    arm_index: 1,
                },
            ],
        };
        assert!(matrix.all_wildcards());
    }

    #[test]
    fn test_pattern_matrix_not_wildcards() {
        let matrix = PatternMatrix {
            rows: vec![
                PatternRow {
                    patterns: vec![Pat::Literal(LitPat::Int(1))],
                    guard: None,
                    arm_index: 0,
                },
                PatternRow {
                    patterns: vec![Pat::Wild],
                    guard: None,
                    arm_index: 1,
                },
            ],
        };
        assert!(!matrix.all_wildcards());
    }

    #[test]
    fn test_pattern_matrix_specialize_literal() {
        let matrix = PatternMatrix {
            rows: vec![
                PatternRow {
                    patterns: vec![Pat::Literal(LitPat::Int(1))],
                    guard: None,
                    arm_index: 0,
                },
                PatternRow {
                    patterns: vec![Pat::Literal(LitPat::Int(2))],
                    guard: None,
                    arm_index: 1,
                },
                PatternRow {
                    patterns: vec![Pat::Wild],
                    guard: None,
                    arm_index: 2,
                },
            ],
        };

        let specialized = matrix.specialize_literal(0, &LitPat::Int(1));
        assert_eq!(specialized.rows.len(), 2); // matching literal + wildcard
        assert_eq!(specialized.rows[0].arm_index, 0);
        assert_eq!(specialized.rows[1].arm_index, 2);
    }

    #[test]
    fn test_pattern_matrix_default() {
        let matrix = PatternMatrix {
            rows: vec![
                PatternRow {
                    patterns: vec![Pat::Literal(LitPat::Int(1))],
                    guard: None,
                    arm_index: 0,
                },
                PatternRow {
                    patterns: vec![Pat::Wild],
                    guard: None,
                    arm_index: 1,
                },
            ],
        };

        let default = matrix.default(0);
        assert_eq!(default.rows.len(), 1);
        assert_eq!(default.rows[0].arm_index, 1);
    }

    #[test]
    fn test_ctor_kind_arity() {
        assert_eq!(CtorKind::Tuple(3).arity(), 3);
        assert_eq!(CtorKind::Array(5).arity(), 5);
        assert_eq!(CtorKind::Box.arity(), 1);
        assert_eq!(CtorKind::Ref { mutable: false }.arity(), 1);
    }

    #[test]
    fn test_lit_pat_discriminant() {
        assert_eq!(LitPat::Bool(true).to_discriminant(), 1);
        assert_eq!(LitPat::Bool(false).to_discriminant(), 0);
        assert_eq!(LitPat::Int(42).to_discriminant(), 42);
        assert_eq!(LitPat::Char('A').to_discriminant(), 65);
    }

    #[test]
    fn test_pattern_is_wildcard() {
        assert!(Pat::Wild.is_wildcard());
        assert!(
            Pat::Bind {
                name: "x".to_string(),
                inner: None
            }
            .is_wildcard()
        );
        assert!(!Pat::Literal(LitPat::Int(1)).is_wildcard());
    }

    #[test]
    fn test_pattern_binding_name() {
        let pat = Pat::Bind {
            name: "x".to_string(),
            inner: None,
        };
        assert_eq!(pat.binding_name(), Some("x"));

        let wild = Pat::Wild;
        assert_eq!(wild.binding_name(), None);
    }

    #[test]
    fn test_or_pattern_specialize() {
        let matrix = PatternMatrix {
            rows: vec![
                PatternRow {
                    patterns: vec![Pat::Or(vec![
                        Pat::Literal(LitPat::Int(1)),
                        Pat::Literal(LitPat::Int(2)),
                    ])],
                    guard: None,
                    arm_index: 0,
                },
                PatternRow {
                    patterns: vec![Pat::Wild],
                    guard: None,
                    arm_index: 1,
                },
            ],
        };

        let specialized = matrix.specialize_literal(0, &LitPat::Int(1));
        assert_eq!(specialized.rows.len(), 2);
    }
}