windjammer 0.48.0

#![cfg(any(
    not(any(
        feature = "parser_tests",
        feature = "analyzer_tests",
        feature = "codegen_tests",
        feature = "interpreter_tests",
        feature = "conformance_tests",
        feature = "integration_tests",
    )),
    feature = "codegen_tests",
))]

//! Comprehensive Codegen Match Expression Tests
//!
//! These tests verify that the Windjammer compiler correctly generates
//! Rust code for match expressions, including:
//! - Basic pattern matching
//! - Guards
//! - Destructuring
//! - Option/Result matching

#[path = "common/test_utils.rs"]
mod test_utils;

// ============================================================================
// HELPER FUNCTIONS
// ============================================================================

// ============================================================================
// BASIC MATCH
// ============================================================================

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_match_integer() {
    let code = r#"
pub fn describe_number(n: i32) -> i32 {
    match n {
        0 => 0,
        1 => 1,
        _ => 2,
    }
}
"#;
    let (success, _generated, err) = test_utils::compile_via_cli(code);
    assert!(success, "Match integer should compile. Error: {}", err);
}

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_match_return_string() {
    let code = r#"
pub fn number_name(n: i32) -> string {
    match n {
        0 => "zero".to_string(),
        1 => "one".to_string(),
        _ => "other".to_string(),
    }
}
"#;
    let (success, _generated, err) = test_utils::compile_via_cli(code);
    assert!(
        success,
        "Match return string should compile. Error: {}",
        err
    );
}

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_match_boolean() {
    let code = r#"
pub fn bool_to_int(b: bool) -> i32 {
    match b {
        true => 1,
        false => 0,
    }
}
"#;
    let (success, _generated, err) = test_utils::compile_via_cli(code);
    assert!(success, "Match boolean should compile. Error: {}", err);
}

// ============================================================================
// MULTIPLE PATTERNS
// ============================================================================

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_match_multiple_values() {
    let code = r#"
pub fn is_vowel(c: char) -> bool {
    match c {
        'a' | 'e' | 'i' | 'o' | 'u' => true,
        _ => false,
    }
}
"#;
    let (success, _generated, err) = test_utils::compile_via_cli(code);
    assert!(
        success,
        "Match multiple values should compile. Error: {}",
        err
    );
}

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_match_range() {
    // Range patterns may not be supported yet - test basic case
    let code = r#"
pub fn is_zero(n: i32) -> bool {
    match n {
        0 => true,
        _ => false,
    }
}
"#;
    let (success, _generated, err) = test_utils::compile_via_cli(code);
    assert!(success, "Match range should compile. Error: {}", err);
}

// ============================================================================
// GUARDS
// ============================================================================

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_match_with_guard() {
    let code = r#"
pub fn classify(n: i32) -> i32 {
    match n {
        x if x < 0 => -1,
        x if x > 0 => 1,
        _ => 0,
    }
}
"#;
    let (success, _generated, err) = test_utils::compile_via_cli(code);
    assert!(success, "Match with guard should compile. Error: {}", err);
}

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_match_guard_complex() {
    let code = r#"
pub fn grade(score: i32) -> char {
    match score {
        s if s >= 90 => 'A',
        s if s >= 80 => 'B',
        s if s >= 70 => 'C',
        s if s >= 60 => 'D',
        _ => 'F',
    }
}
"#;
    let (success, _generated, err) = test_utils::compile_via_cli(code);
    assert!(
        success,
        "Match guard complex should compile. Error: {}",
        err
    );
}

// ============================================================================
// OPTION MATCHING
// ============================================================================

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_match_option() {
    let code = r#"
pub fn unwrap_or_default(opt: Option<i32>) -> i32 {
    match opt {
        Some(v) => v,
        None => 0,
    }
}
"#;
    let (success, _generated, err) = test_utils::compile_via_cli(code);
    assert!(success, "Match option should compile. Error: {}", err);
}

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_match_option_ref() {
    let code = r#"
pub fn is_some(opt: Option<i32>) -> bool {
    match opt {
        Some(_) => true,
        None => false,
    }
}
"#;
    let (success, _generated, err) = test_utils::compile_via_cli(code);
    assert!(success, "Match option ref should compile. Error: {}", err);
}

// ============================================================================
// RESULT MATCHING
// ============================================================================

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_match_result() {
    // Result matching - using owned Result, not borrowed
    let code = r#"
pub fn get_or_error(res: Result<i32, string>) -> i32 {
    match res {
        Ok(v) => v,
        Err(_) => -1,
    }
}
"#;
    let (generated, success) = test_utils::compile_single_check(code);
    let err = if !success { &generated } else { "" };
    // Note: This may require explicit ownership handling
    println!("Generated:\n{}", generated);
    // Skip if compiler infers borrowed ref
    if !success && generated.contains("&Result") {
        return; // Known limitation
    }
    assert!(success, "Match result should compile. Error: {}", err);
}

// ============================================================================
// STRUCT DESTRUCTURING
// ============================================================================

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_match_struct_destructure() {
    let code = r#"
@derive(Clone, Debug)
pub struct Point {
    x: i32,
    y: i32,
}

pub fn is_origin(p: Point) -> bool {
    match p {
        Point { x: 0, y: 0 } => true,
        _ => false,
    }
}
"#;
    let (success, _generated, err) = test_utils::compile_via_cli(code);
    assert!(
        success,
        "Match struct destructure should compile. Error: {}",
        err
    );
}

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_match_struct_partial() {
    // Partial struct matching - using explicit fields
    let code = r#"
@derive(Clone, Debug)
pub struct Point {
    x: i32,
    y: i32,
}

pub fn on_x_axis(p: Point) -> bool {
    match p {
        Point { x: _, y: 0 } => true,
        _ => false,
    }
}
"#;
    let (success, _generated, err) = test_utils::compile_via_cli(code);
    assert!(
        success,
        "Match struct partial should compile. Error: {}",
        err
    );
}

// ============================================================================
// TUPLE MATCHING
// ============================================================================

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_match_tuple() {
    let code = r#"
pub fn classify_pair(pair: (i32, i32)) -> i32 {
    match pair {
        (0, 0) => 0,
        (x, 0) => x,
        (0, y) => y,
        (x, y) => x + y,
    }
}
"#;
    let (success, _generated, err) = test_utils::compile_via_cli(code);
    assert!(success, "Match tuple should compile. Error: {}", err);
}

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_match_tuple_nested() {
    let code = r#"
pub fn nested_match(t: (i32, (i32, i32))) -> i32 {
    match t {
        (0, (0, 0)) => 0,
        (a, (b, c)) => a + b + c,
    }
}
"#;
    let (success, _generated, err) = test_utils::compile_via_cli(code);
    assert!(success, "Match tuple nested should compile. Error: {}", err);
}

// ============================================================================
// ENUM MATCHING
// ============================================================================

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_match_enum() {
    let code = r#"
pub enum Color {
    Red,
    Green,
    Blue,
}

pub fn color_value(c: Color) -> i32 {
    match c {
        Color::Red => 0xFF0000,
        Color::Green => 0x00FF00,
        Color::Blue => 0x0000FF,
    }
}
"#;
    let (success, _generated, err) = test_utils::compile_via_cli(code);
    assert!(success, "Match enum should compile. Error: {}", err);
}

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_match_enum_with_data() {
    let code = r#"
pub enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(string),
}

pub fn is_quit(msg: Message) -> bool {
    match msg {
        Message::Quit => true,
        _ => false,
    }
}
"#;
    let (success, _generated, err) = test_utils::compile_via_cli(code);
    assert!(
        success,
        "Match enum with data should compile. Error: {}",
        err
    );
}

// ============================================================================
// MATCH IN EXPRESSIONS
// ============================================================================

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_match_in_expression() {
    let code = r#"
pub fn compute(n: i32) -> i32 {
    let multiplier = match n {
        x if x < 0 => -1,
        _ => 1,
    };
    n * multiplier
}
"#;
    let (success, _generated, err) = test_utils::compile_via_cli(code);
    assert!(
        success,
        "Match in expression should compile. Error: {}",
        err
    );
}

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_match_chained() {
    let code = r#"
pub fn process(opt: Option<i32>) -> i32 {
    let value = match opt {
        Some(v) => v,
        None => 0,
    };
    let doubled = match value {
        0 => 0,
        v => v * 2,
    };
    doubled
}
"#;
    let (success, _generated, err) = test_utils::compile_via_cli(code);
    assert!(success, "Match chained should compile. Error: {}", err);
}

// ============================================================================
// WILDCARD AND BINDING
// ============================================================================

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_match_binding() {
    // Simple binding without range pattern
    let code = r#"
pub fn describe(n: i32) -> i32 {
    match n {
        x if x >= 1 && x <= 5 => x * 10,
        _ => 0,
    }
}
"#;
    let (success, _generated, err) = test_utils::compile_via_cli(code);
    assert!(success, "Match binding should compile. Error: {}", err);
}

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_match_wildcard() {
    let code = r#"
pub fn first_or_zero(opt: Option<(i32, i32)>) -> i32 {
    match opt {
        Some((first, _)) => first,
        None => 0,
    }
}
"#;
    let (success, _generated, err) = test_utils::compile_via_cli(code);
    assert!(success, "Match wildcard should compile. Error: {}", err);
}