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

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

// Test: Trait method signatures should use EXACT types from source (no inference)
// Bug: Trait methods with default implementations were getting ownership inference
// Expected: `delta: f32` in source → `delta: f32` in generated (NOT `delta: &f32`)

use std::process::Command;

fn compile_and_check(code: &str) -> (bool, String) {
    // Use unique temp directory per test to avoid parallel test conflicts
    // Use thread ID to ensure uniqueness even within same test binary
    let thread_id = format!("{:?}", std::thread::current().id());
    let _tmp = tempfile::tempdir().unwrap();
    let temp_dir = _tmp.path().join(format!("trait_test_{}", thread_id));

    let test_file = temp_dir.join("test.wj");
    let output_dir = temp_dir.join("output");

    std::fs::create_dir_all(&output_dir).ok();
    std::fs::write(&test_file, code).unwrap();

    let output = Command::new(env!("CARGO_BIN_EXE_wj"))
        .args([
            "build",
            test_file.to_str().unwrap(),
            "--output",
            output_dir.to_str().unwrap(),
            "--no-cargo",
        ])
        .output()
        .expect("Failed to run wj");

    let generated_file = output_dir.join("test.rs");
    let generated = std::fs::read_to_string(&generated_file).unwrap_or_default();

    // Clean up

    (output.status.success(), generated)
}

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_trait_method_no_inference_f32() {
    let code = r#"
pub trait GameLoop {
    fn update(delta: f32) {
        // Default implementation
    }
}
"#;

    let (success, generated) = compile_and_check(code);
    assert!(success, "Should compile successfully");

    // Check that trait signature uses f32, not &f32
    assert!(
        generated.contains("fn update(&self, delta: f32)"),
        "Empty default impl does not mutate — trait uses &self. Generated:\n{}",
        generated
    );

    // Ensure it's NOT generating &f32
    assert!(
        !generated.contains("delta: &f32"),
        "Trait method should NOT have '&f32'. Generated:\n{}",
        generated
    );
}

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_trait_method_no_inference_struct() {
    let code = r#"
pub struct Input { pub key: int }
pub struct RenderContext { pub width: int }

pub trait GameLoop {
    fn update(input: Input) {
        // Default implementation
    }
    
    fn render(ctx: RenderContext) {
        // Default implementation
    }
}
"#;

    let (success, generated) = compile_and_check(code);
    assert!(success, "Should compile successfully");

    // Check that trait signatures use owned types, not references
    assert!(
        generated.contains("fn update(&self, input: Input)"),
        "Empty default impl does not mutate — trait uses &self. Generated:\n{}",
        generated
    );
    assert!(generated.contains("fn render(&self, ctx: RenderContext)"), 
        "Trait method should have 'ctx: RenderContext' (owned), not '&RenderContext'. Generated:\n{}", generated);
}

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_trait_impl_can_use_references() {
    let code = r#"
pub struct Input { pub key: int }

pub trait GameLoop {
    fn update(input: Input);
}

pub struct MyGame {}

impl GameLoop for MyGame {
    fn update(input: Input) {
        // Implementation - can use references if needed
        println(input.key)
    }
}
"#;

    let (success, generated) = compile_and_check(code);
    assert!(success, "Should compile successfully");

    // Trait signature should be owned
    assert!(
        generated.contains("fn update(&self, input: Input);"),
        "Read-only impl keeps trait at &self. Generated:\n{}",
        generated
    );

    // Implementation matches trait signature
    // (The implementation will also have Input because it must match the trait)
}