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
149
150
151
152
153

#![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 Test: Fix HashMap.get() double-reference bug
//!
//! Bug: When calling HashMap.get() with an already-borrowed key from .keys(),
//! the transpiler incorrectly adds another `&`, resulting in `&&String` instead of `&String`.
//!
//! Example:
//!   Windjammer: `map.get(key)` where key is `&String`
//!   Generated:  `map.get(&key)` which is `&&String` ❌
//!   Should be:  `map.get(key)` which is `&String` ✅

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

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_hashmap_get_with_borrowed_key_from_keys() {
    // Test Case 1: HashMap.get() with key from .keys() iterator
    let code = r#"
use std::collections::HashMap

pub fn get_values(map: HashMap<string, i32>) -> Vec<i32> {
    let mut result = Vec::new()
    
    for key in map.keys() {
        let value = map.get(key)
        match value {
            Some(v) => result.push(*v),
            None => {}
        }
    }
    
    result
}
"#;

    let (generated, success) = test_utils::compile_single_check(code);
    let err = if !success { &generated } else { "" };

    println!("Generated:\n{}", generated);
    if !success {
        println!("Rustc error:\n{}", err);
    }

    // Should NOT contain map.get(&key) which causes double-ref
    assert!(
        !generated.contains("map.get(&key)"),
        "Generated code should not double-reference key: map.get(&key) is wrong"
    );

    // Should contain map.get(key)
    assert!(
        generated.contains("map.get(key)"),
        "Generated code should use single reference: map.get(key)"
    );

    assert!(
        success,
        "Generated Rust code should compile successfully. Rustc error:\n{}",
        err
    );
}

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_hashmap_get_with_owned_key() {
    // Test Case 2: HashMap.get() with owned String key
    let code = r#"
use std::collections::HashMap

pub fn lookup(map: HashMap<string, i32>, key: string) -> Option<i32> {
    match map.get(key) {
        Some(v) => Some(*v),
        None => None
    }
}
"#;

    let (generated, success) = test_utils::compile_single_check(code);
    let err = if !success { &generated } else { "" };

    println!("Generated:\n{}", generated);
    if !success {
        println!("Rustc error:\n{}", err);
    }

    // When key is owned String, should auto-borrow to &String
    assert!(
        generated.contains("map.get(&key)") || generated.contains("map.get(key)"),
        "Generated code should handle owned String key correctly"
    );

    assert!(
        success,
        "Generated Rust code should compile successfully. Rustc error:\n{}",
        err
    );
}

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_hashmap_get_with_explicit_borrowed_key() {
    // Test Case 3: read-only string param infers &str in Rust — get() call must compile
    let code = r#"
use std::collections::HashMap

pub fn lookup_borrowed(map: HashMap<string, i32>, key: string) -> Option<i32> {
    match map.get(key) {
        Some(v) => Some(*v),
        None => None
    }
}
"#;

    let (generated, success) = test_utils::compile_single_check(code);
    let err = if !success { &generated } else { "" };

    println!("Generated:\n{}", generated);
    if !success {
        println!("Rustc error:\n{}", err);
    }

    // Read-only string param should generate &str
    assert!(
        generated.contains("key: &str"),
        "Read-only string param should infer &str. Got:\n{}",
        generated
    );

    // Accept either direct key or auto-borrow form (same as owned-key test)
    assert!(
        generated.contains("map.get(&key)") || generated.contains("map.get(key)"),
        "HashMap.get should accept inferred &str key. Got:\n{}",
        generated
    );

    assert!(
        success,
        "Generated Rust code should compile successfully. Rustc error:\n{}",
        err
    );
}