ruchy 4.1.2

A systems scripting language that transpiles to idiomatic Rust with extreme quality engineering
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174

#![allow(missing_docs)]
//! PARSER-089: Fix parser handling of reference parameters with match expressions (GitHub Issue #73)
//!
//! ROOT CAUSE: When parsing a function with reference-type parameters (`&str`),
//! the parser incorrectly remains in "parameter parsing mode" after finishing the
//! parameter list. When it encounters a match expression's closing brace `}`, it
//! misinterprets it as an invalid parameter.
//!
//! FIX: Properly reset parser state after parsing reference-type parameters.
//!
//! DISCOVERED VIA: Binary search/bisection testing
//! - ✅ Works: Function WITHOUT parameter, WITH match + method chain
//! - ❌ Fails: Function WITH parameter (`&str`), WITH match + method chain
//! - ✅ Works: Function WITH parameter, WITHOUT match
//! - ROOT: Reference parameter parsing doesn't reset state before match expression

use std::fs;
use tempfile::NamedTempFile;

fn write_and_check(code: &str) {
    let temp_file = NamedTempFile::new().unwrap();
    fs::write(temp_file.path(), code).unwrap();

    let mut cmd = assert_cmd::cargo::cargo_bin_cmd!("ruchy");
    cmd.arg("check").arg(temp_file.path()).assert().success();
}

/// Test minimal reproduction case: reference parameter + match expression
#[test]
fn test_parser_089_ref_param_with_match() {
    let code = r#"
use std::process::Command;

pub fun check_command(command: &str) -> bool {
    let result = Command::new("which").arg(command).output();
    match result {
        Ok(output) => output.status.success(),
        Err(_) => false,
    }
}
"#;
    write_and_check(code);
}

/// Test that reference parameters work WITHOUT match (baseline)
#[test]
fn test_parser_089_ref_param_no_match_works() {
    let code = r#"
use std::process::Command;

pub fun test(command: &str) -> bool {
    let result = Command::new("which").arg(command).output();
    true
}
"#;
    write_and_check(code);
}

/// Test that match works WITHOUT reference parameters (baseline)
#[test]
fn test_parser_089_match_no_ref_param_works() {
    let code = r#"
use std::process::Command;

pub fun test() -> bool {
    let result = Command::new("which").arg("test").output();
    match result {
        Ok(output) => output.status.success(),
        Err(_) => false,
    }
}
"#;
    write_and_check(code);
}

/// Test multiple reference parameters with match
#[test]
fn test_parser_089_multiple_ref_params_with_match() {
    let code = r#"
pub fun check_two(first: &str, second: &str) -> bool {
    let result = match first {
        "ok" => true,
        _ => false,
    };
    match second {
        "valid" => result,
        _ => false,
    }
}
"#;
    write_and_check(code);
}

/// Test nested match expressions with reference parameter
#[test]
fn test_parser_089_nested_match_with_ref_param() {
    let code = r#"
pub fun nested_check(input: &str) -> i32 {
    match input {
        "a" => match "x" {
            "x" => 1,
            _ => 2,
        },
        _ => 3,
    }
}
"#;
    write_and_check(code);
}

/// Test original Issue #73 reproduction case (32 lines)
#[test]
fn test_parser_089_issue_73_full_reproduction() {
    let code = r#"
use std::process::Command;

pub fun check_command(command: &str) -> bool {
    let result = Command::new("which")
        .arg(command)
        .output();

    match result {
        Ok(output) => output.status.success(),
        Err(_) => false,
    }
}

pub fun validate_dependencies(deps: Vec<String>) -> bool {
    let mut all_present = true;

    for dep in deps {
        let exists = check_command(&dep);
        if !exists {
            println!("Missing dependency: {}", dep);
            all_present = false;
        } else {
            println!("Found dependency: {}", dep);
        }
    }

    all_present
}
"#;
    write_and_check(code);
}

/// Test mutable reference parameter with match
#[test]
fn test_parser_089_mut_ref_param_with_match() {
    let code = r"
pub fun modify_and_check(value: &mut i32) -> bool {
    *value += 1;
    match *value {
        1 => true,
        _ => false,
    }
}
";
    write_and_check(code);
}

/// Test mixed value and reference parameters with match
#[test]
fn test_parser_089_mixed_params_with_match() {
    let code = r#"
pub fun mixed(owned: String, borrowed: &str, number: i32) -> bool {
    match borrowed {
        "test" => number > 0,
        _ => false,
    }
}
"#;
    write_and_check(code);
}