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
154
155
156

#![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: Auto-clone when pushing iterator items to new Vec
//!
//! When iterating over self.field and pushing items to a new Vec,
//! the items should be cloned since the iterator returns references.

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

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_filter_self_items_to_new_vec() {
    // Common pattern: filter items from self and collect into new Vec
    let code = r#"
@derive(Clone, Debug)
pub struct Item {
    id: i32,
    name: string,
}

@derive(Clone, Debug)
pub struct Container {
    items: Vec<Item>,
}

impl Container {
    pub fn new() -> Container {
        Container { items: Vec::new() }
    }
    
    // Filter items and return a new Vec
    pub fn filter_by_id(self, min_id: i32) -> Vec<Item> {
        let mut result = Vec::new()
        for item in self.items {
            if item.id >= min_id {
                result.push(item)
            }
        }
        result
    }
}
"#;

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

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

    // Should auto-clone items when pushing to result
    assert!(success, "Generated code should compile. Error: {}", err);
}

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_remove_item_rebuild_vec() {
    // Pattern: rebuild vec without certain items
    let code = r#"
@derive(Clone, Debug)
pub struct Bus {
    name: string,
    volume: f32,
}

@derive(Clone, Debug)
pub struct Mixer {
    buses: Vec<Bus>,
}

impl Mixer {
    pub fn new() -> Mixer {
        Mixer { buses: Vec::new() }
    }
    
    // Remove bus at index by rebuilding Vec
    pub fn remove_bus(self, index: i32) {
        let mut new_buses = Vec::new()
        let mut i = 0
        for bus in self.buses {
            if i != index {
                new_buses.push(bus)
            }
            i = i + 1
        }
        self.buses = new_buses
    }
}
"#;

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

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

    assert!(success, "Generated code should compile. Error: {}", err);
}

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_copy_matching_items() {
    // Copy items that match a condition
    let code = r#"
@derive(Clone, Debug, Copy)
pub struct Node {
    id: i32,
    parent_id: i32,
}

@derive(Clone, Debug)
pub struct Tree {
    nodes: Vec<Node>,
}

impl Tree {
    pub fn new() -> Tree {
        Tree { nodes: Vec::new() }
    }
    
    pub fn get_children(self, parent: i32) -> Vec<Node> {
        let mut children = Vec::new()
        for node in self.nodes {
            if node.parent_id == parent {
                children.push(node)
            }
        }
        children
    }
}
"#;

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

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

    assert!(success, "Generated code should compile. Error: {}", err);
}