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

/// TDD regression test: Struct builder methods named `max`/`min` must NOT
/// trigger float inference conflicts with `f64::max`/`f32::max`.
///
/// Bug: `Slider::new().min(0.0).max(100.0)` caused the float inference engine
/// to match `.max(100.0)` against `f64::max(self, other)` because:
///   1. `determine_method_return_type` blindly returned `f32` for any
///      MethodCall-on-MethodCall where the method name was in F32_METHODS
///   2. The function-signature lookup matched `f64::max` by basename + arity
///
/// Root cause: No receiver-type check — struct builder methods like
/// `Slider::max` collided with numeric methods `f64::max`.
use std::process::Command;

fn compile_wj(source: &str) -> String {
    let dir = tempfile::tempdir().unwrap();
    let src = dir.path().join("test.wj");
    std::fs::write(&src, source).unwrap();
    let output = Command::new(env!("CARGO_BIN_EXE_wj"))
        .args(["build", "--no-cargo", src.to_str().unwrap(), "--target", "rust"])
        .output()
        .unwrap();
    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
    format!("{}\n{}", stdout, stderr)
}

fn compile_wj_to_rust(source: &str) -> String {
    let dir = tempfile::tempdir().unwrap();
    let src = dir.path().join("test.wj");
    std::fs::write(&src, source).unwrap();
    let out_dir = dir.path().join("out");
    let output = Command::new(env!("CARGO_BIN_EXE_wj"))
        .args([
            "build",
            "--no-cargo",
            src.to_str().unwrap(),
            "--target",
            "rust",
            "-o",
            out_dir.to_str().unwrap(),
        ])
        .output()
        .unwrap();
    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
    if !stderr.is_empty() {
        eprintln!("Compiler stderr:\n{}", stderr);
    }
    // The compiler outputs to a directory; the .rs file name matches the source.
    let rs_file = out_dir.join("test.rs");
    std::fs::read_to_string(&rs_file).unwrap_or_else(|_| "FILE NOT GENERATED".to_string())
}

#[test]
fn test_struct_builder_max_no_float_inference_conflict() {
    let source = r#"
pub struct Slider {
    min: float,
    max: float,
    step: float,
    value: float,
}

impl Slider {
    pub fn new() -> Slider {
        Slider { min: 0.0, max: 100.0, step: 1.0, value: 50.0 }
    }

    pub fn min(self, min: float) -> Slider {
        self.min = min
        self
    }

    pub fn max(self, max: float) -> Slider {
        self.max = max
        self
    }

    pub fn value(self, value: float) -> Slider {
        self.value = value
        self
    }
}

fn main() {
    let slider = Slider::new().min(0.0).max(100.0).value(75.0)
}
"#;

    let combined = compile_wj(source);
    assert!(
        !combined.contains("Float inference error"),
        "Float inference should NOT produce errors for struct builder methods!\nOutput:\n{}",
        combined
    );
}

#[test]
fn test_struct_builder_min_no_float_inference_conflict() {
    let source = r#"
pub struct Config {
    min: float,
    max: float,
}

impl Config {
    pub fn new() -> Config {
        Config { min: 0.0, max: 1.0 }
    }

    pub fn min(self, val: float) -> Config {
        self.min = val
        self
    }

    pub fn max(self, val: float) -> Config {
        self.max = val
        self
    }
}

fn main() {
    let c = Config::new().min(0.5).max(1.5)
}
"#;

    let combined = compile_wj(source);
    assert!(
        !combined.contains("Float inference error"),
        "Float inference should NOT produce errors for struct builder .min()/.max()!\nOutput:\n{}",
        combined
    );
}

#[test]
fn test_real_float_max_still_works() {
    let source = r#"
fn main() {
    let x: f32 = 3.0
    let y: f32 = 5.0
    let z = x.max(y)
}
"#;

    let rust = compile_wj_to_rust(source);
    assert!(
        !rust.contains("Float inference error") && rust != "FILE NOT GENERATED",
        "Real f32::max should still work!\nOutput:\n{}",
        rust
    );
}