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
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

#![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",
))]

/// TDD Tests for Phase 3 Parameter Decorators
///
/// These tests verify manual override decorators:
/// - @str_ref forces &str (developer promises it's safe)
/// - @string_ref forces &String (conservative override)
#[path = "common/test_utils.rs"]
mod test_utils;

#[test]
fn test_str_ref_decorator_forces_str() {
    // TDD: @str_ref forces &str even if function uses Vec<String> methods
    // NOTE: This will cause rustc E0308, but that's the developer's responsibility
    let code = r#"
pub fn log(@str_ref msg: string) {
    println!("{}", msg)
}

fn main() {
    log("Hello")
}
"#;

    let generated = test_utils::compile_single_result(code).expect("Compilation failed");

    println!("Generated:\n{}", generated);

    // PHASE 3: @str_ref forces &str
    assert!(
        generated.contains("fn log(msg: &str)"),
        "Expected @str_ref to force &str parameter. Generated:\n{}",
        generated
    );

    // String literal should pass directly (no conversion)
    assert!(
        generated.contains(r#"log("Hello")"#),
        "Expected direct string literal with &str param. Generated:\n{}",
        generated
    );
}

#[test]
fn test_string_ref_decorator_forces_string() {
    // TDD: @string_ref forces &String even if auto-optimization would choose &str
    let code = r#"
pub fn log(@string_ref msg: string) {
    println!("{}", msg)
}

fn main() {
    log("Hello")
}
"#;

    let generated = test_utils::compile_single_result(code).expect("Compilation failed");

    println!("Generated:\n{}", generated);

    // PHASE 3: @string_ref forces &String
    assert!(
        generated.contains("fn log(msg: &String)"),
        "Expected @string_ref to force &String parameter. Generated:\n{}",
        generated
    );

    // String literal must be converted
    assert!(
        generated.contains(r#"log(&"Hello".to_string())"#),
        "Expected converted string literal with &String param. Generated:\n{}",
        generated
    );
}

#[test]
fn test_mixed_decorated_and_inferred_params() {
    // TDD: Mix of decorated and inferred parameters
    let code = r#"
pub fn process(@str_ref fast: string, @string_ref safe: string, inferred: string) {
    println!("{} {} {}", fast, safe, inferred)
}

fn main() {
    process("a", "b", "c")
}
"#;

    let generated = test_utils::compile_single_result(code).expect("Compilation failed");

    println!("Generated:\n{}", generated);

    // PHASE 3: Decorators override, inferred uses Phase 2 automatic optimization
    // With Phase 2 enabled globally, non-decorated params are optimized to &str when safe
    assert!(
        generated.contains("fn process(fast: &str, safe: &String, inferred: &str)"),
        "Expected mixed decorators: fast=&str (decorator), safe=&String (decorator), inferred=&str (Phase 2 auto-opt). Generated:\n{}",
        generated
    );
}

#[test]
fn test_decorator_overrides_automatic_analysis() {
    // TDD: @str_ref overrides automatic analysis even when it would choose &String
    // This test will be relevant when automatic analysis is fully implemented
    let code = r#"
struct Store {
    items: Vec<string>
}

impl Store {
    // Developer promises this is safe (maybe they know Vec methods aren't called)
    pub fn check(@str_ref item_id: string) -> bool {
        // In reality, if this calls self.items.contains(item_id), rustc will error
        // But that's the developer's responsibility when using @str_ref
        item_id.len() > 0
    }
}

fn main() {
    let store = Store { items: Vec::new() }
    let result = store.check("test")
    println!("{}", result)
}
"#;

    let generated = test_utils::compile_single_result(code).expect("Compilation failed");

    println!("Generated:\n{}", generated);

    // PHASE 3: @str_ref forces &str (even as static method)
    // Note: Method defined without self, so it's a static method
    assert!(
        generated.contains("fn check(item_id: &str)"),
        "Expected @str_ref to force &str in static method. Generated:\n{}",
        generated
    );
}