windjammer 0.48.0

A simple language inspired by Go, Ruby, and Elixir that transpiles to Rust - 80% of Rust's power with 20% of the complexity
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

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

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

#[test]
fn test_compound_assignment_function_call() {
    let source = r#"
pub fn greet(name: string) -> string {
    format!("Hello, {}!", name)
}

pub fn build_greetings() -> string {
    let mut result = ""
    result += greet("Alice")
    result += greet("Bob")
    result
}
"#;

    let (output, success) = test_utils::compile_single_check(source);

    println!("\n=== Generated Rust ===\n{}\n", output);

    assert!(success, "Generated Rust should compile without errors");

    // Should either use & prefix OR convert to regular assignment
    let has_borrow = output.contains("result += &greet");
    let has_assignment = output.contains("result = result + ");

    assert!(
        has_borrow || has_assignment,
        "Should either add & prefix or use regular assignment: {}",
        output
    );
}

#[test]
fn test_compound_assignment_method_call() {
    let source = r#"
struct Renderer {
    prefix: string,
}

impl Renderer {
    pub fn render(self, text: string) -> string {
        format!("{}: {}", self.prefix, text)
    }
}

pub fn render_all(r: Renderer) -> string {
    let mut html = ""
    html += r.render("line1")
    html += r.render("line2")
    html
}
"#;

    let (output, success) = test_utils::compile_single_check(source);

    println!("\n=== Generated Rust ===\n{}\n", output);

    assert!(success, "Generated Rust should compile without errors");
}

#[test]
fn test_compound_assignment_format_macro() {
    let source = r#"
pub fn build_report(name: string, score: i32) -> string {
    let mut output = ""
    output += format!("Name: {}", name)
    output += format!("Score: {}", score)
    output
}
"#;

    let (output, success) = test_utils::compile_single_check(source);

    println!("\n=== Generated Rust ===\n{}\n", output);

    assert!(success, "Generated Rust should compile without errors");
}

#[test]
fn test_compound_assignment_mixed() {
    let source = r#"
pub fn format_value(v: i32) -> string {
    format!("{}", v)
}

pub fn build_mixed() -> string {
    let mut result = ""
    result += "Prefix: "      // string literal (already &string) - should work
    result += format_value(42) // Function returning string - needs fix
    result += " - Suffix"     // string literal - should work
    result
}
"#;

    let (output, success) = test_utils::compile_single_check(source);

    println!("\n=== Generated Rust ===\n{}\n", output);

    assert!(success, "Generated Rust should compile without errors");
}

// Helper function