ruchy 4.2.0

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

//! CRITICAL TRANSPILER BUG TEST - String type handling (Issue #13)
//! This follows EXTREME TDD protocol for transpiler bugs

use ruchy::{Parser, Transpiler};

#[test]
fn test_str_parameter_transpilation() {
    // Check that Ruchy 'str' type maps to Rust '&str' in parameters
    let mut parser = Parser::new("fun greet(name: str) { println(name) }");
    let ast = parser.parse().expect("Should parse");

    let mut transpiler = Transpiler::new();
    let result = transpiler.transpile_to_program(&ast);

    assert!(result.is_ok(), "Should transpile successfully");
    let code = result.unwrap().to_string();

    println!("Generated code: {code}"); // Debug output

    // Should use &str, not str (accounting for spacing)
    assert!(
        code.contains("& str") || code.contains("&str"),
        "Function parameter should be &str"
    );
    assert!(
        !code.contains("name : str"),
        "Should not use unsized str type"
    );
}

#[test]
fn test_string_literal_no_unnecessary_to_string() {
    // Check that string literals don't get .to_string() when passed to &str parameters
    let mut parser = Parser::new("fun main() { greet(\"Hello\") }");
    let ast = parser.parse().expect("Should parse");

    let mut transpiler = Transpiler::new();
    let result = transpiler.transpile_to_program(&ast);

    assert!(result.is_ok(), "Should transpile successfully");
    let code = result.unwrap().to_string();

    // Should NOT add unnecessary .to_string()
    assert!(
        !code.contains("\"Hello\" . to_string ()"),
        "Should not add .to_string() to string literals"
    );
}

#[test]
fn test_println_format_correctness() {
    // Check that println!("{}", name) generates correct format, not "{} {:?}"
    let mut parser = Parser::new("fun test() { println(\"Hello, {}!\", \"World\") }");
    let ast = parser.parse().expect("Should parse");

    let mut transpiler = Transpiler::new();
    let result = transpiler.transpile_to_program(&ast);

    assert!(result.is_ok(), "Should transpile successfully");
    let code = result.unwrap().to_string();

    // Should use correct println format
    assert!(!code.contains("\"{} {:?}\""), "Should not use debug format");
    assert!(code.contains("println !"), "Should generate println! macro");
}

#[test]
fn test_no_unnecessary_hashmap_import() {
    // Check that simple functions don't generate unused HashMap import
    let mut parser = Parser::new("fun main() { println(\"Hello\") }");
    let ast = parser.parse().expect("Should parse");

    let mut transpiler = Transpiler::new();
    let result = transpiler.transpile_to_program(&ast);

    assert!(result.is_ok(), "Should transpile successfully");
    let code = result.unwrap().to_string();

    // Should NOT include unnecessary HashMap import
    assert!(
        !code.contains("use std :: collections :: HashMap"),
        "Should not import HashMap unnecessarily"
    );
}

#[test]
fn test_no_extra_braces() {
    // Check that function bodies don't get double-wrapped in braces
    let mut parser = Parser::new("fun test() { 42 }");
    let ast = parser.parse().expect("Should parse");

    let mut transpiler = Transpiler::new();
    let result = transpiler.transpile_to_program(&ast);

    assert!(result.is_ok(), "Should transpile successfully");
    let code = result.unwrap().to_string();

    // Should not have double braces {{ }}
    assert!(!code.contains("{ {"), "Should not generate nested braces");
    assert!(!code.contains("} }"), "Should not generate nested braces");
}

#[test]
fn test_complete_string_example_compiles() {
    // Integration test: Full example from Issue #13 should compile successfully
    let code = r#"
        fun greet(name: str) {
            println("Hello, {}!", name)
        }
        
        fun main() {
            greet("World")
        }
    "#;

    let mut parser = Parser::new(code);
    let ast = parser.parse().expect("Should parse");

    let mut transpiler = Transpiler::new();
    let result = transpiler.transpile_to_program(&ast);

    assert!(result.is_ok(), "Should transpile without errors");

    // The generated Rust code should compile (we'll test this in CI)
    let generated = result.unwrap().to_string();

    // Basic sanity checks for correct transpilation
    assert!(
        generated.contains("&str") || generated.contains("& str"),
        "Should use &str for parameters"
    );
    assert!(
        !generated.contains("name : str)"),
        "Should not use unsized str"
    );
    assert!(
        !generated.contains("\"World\" . to_string"),
        "Should not add .to_string() unnecessarily"
    );
}