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

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

// Pattern: member_index as f32 * 6.28318 / count as f32 (ai/squad_tactics Circle formation)

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

#[test]
fn test_squad_tactics_formation_angle() {
    let source = r#"
pub fn formation_angle(member_index: i32, count: i32) -> f32 {
    member_index as f32 * 6.28318 / count as f32
}
"#;

    let output = test_utils::compile_single(source);
    let has_f32_safety = output.contains("as f32") || output.contains("_f32");
    assert!(
        has_f32_safety,
        "Squad tactics pattern should have f32 consistency. Got:\n{}",
        output
    );

    let __result = test_utils::verify_rust_compiles(&output);
    let rustc_ok = __result.is_ok();
    let stderr = __result.err().unwrap_or_default();
    assert!(
        rustc_ok || !stderr.contains("cannot multiply") && !stderr.contains("cannot divide"),
        "E0277 squad_tactics:\nstderr: {}\n\nGenerated:\n{}",
        stderr,
        output
    );
}

/// Pattern: (seed * 1234.567).sin() * 3.14159265 * 2.0 (particles/emitter)
#[test]
fn test_emitter_angle_chain() {
    let source = r#"
pub fn emit_angle(seed: f32) -> f32 {
    (seed * 1234.567).sin() * 3.14159265 * 2.0
}
"#;

    let output = test_utils::compile_single(source);
    let has_f32_safety = output.contains("as f32") || output.contains("_f32");
    assert!(
        has_f32_safety,
        "Emitter pattern should have f32 consistency. Got:\n{}",
        output
    );

    let __result = test_utils::verify_rust_compiles(&output);
    let rustc_ok = __result.is_ok();
    let stderr = __result.err().unwrap_or_default();
    assert!(
        rustc_ok || !stderr.contains("cannot multiply") && !stderr.contains("cannot add"),
        "E0277 emitter:\nstderr: {}\n\nGenerated:\n{}",
        stderr,
        output
    );
}

/// Pattern: f32 + i32 (calculate_cost from pathfinding)
#[test]
fn test_calculate_cost_f32_add_i32() {
    let source = r#"
pub fn calculate_cost(base: f32, penalty: i32) -> f32 {
    base + penalty
}
"#;

    let output = test_utils::compile_single(source);
    // Codegen may emit `(penalty as f32) as f32` (redundant but valid) or `(penalty) as f32`
    assert!(
        output.contains("penalty as f32")
            || output.contains("(penalty) as f32")
            || output.contains("(base) as f32"),
        "base + penalty should cast int to f32. Got:\n{}",
        output
    );

    let __result = test_utils::verify_rust_compiles(&output);
    let rustc_ok = __result.is_ok();
    let stderr = __result.err().unwrap_or_default();
    assert!(
        rustc_ok || !stderr.contains("cannot add"),
        "E0277 calculate_cost:\nstderr: {}\n\nGenerated:\n{}",
        stderr,
        output
    );
}

/// Pattern: f32 += i32 (compound assignment)
#[test]
fn test_compound_f32_add_assign_i32() {
    let source = r#"
pub fn accumulate(total: f32, value: i32) -> f32 {
    let mut t = total;
    t += value;
    t
}
"#;

    let output = test_utils::compile_single(source);
    let has_cast = output.contains("as f32");
    assert!(
        has_cast,
        "t += value should cast value to f32. Got:\n{}",
        output
    );

    let __result = test_utils::verify_rust_compiles(&output);
    let rustc_ok = __result.is_ok();
    let stderr = __result.err().unwrap_or_default();
    assert!(
        rustc_ok || !stderr.contains("cannot add"),
        "E0277 compound assign:\nstderr: {}\n\nGenerated:\n{}",
        stderr,
        output
    );
}