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

#![cfg(any(
    not(any(
        feature = "parser_tests",
        feature = "analyzer_tests",
        feature = "codegen_tests",
        feature = "interpreter_tests",
        feature = "conformance_tests",
        feature = "integration_tests",
    )),
    feature = "codegen_tests",
))]

/// TDD: Float literal inference in binary operations
/// BUG: `f32_value * 1.414` generates `f32_value * 1.414_f64` (type mismatch)
/// FIX: Infer float literals from operand types in binary operations
use std::fs;
use std::process::Command;
use tempfile::TempDir;

#[test]
fn test_float_literal_in_f32_binary_op() {
    let wj_source = r#"
fn get_distance(x: f32, y: f32) -> f32 {
    let dx = x * x
    let dy = y * y
    let dist_sq = dx + dy
    dist_sq * 1.414  // Should be 1.414_f32, not 1.414_f64
}

fn main() {
    let d = get_distance(3.0, 4.0)
    println!("{}", d)
}
"#;

    let temp_dir = TempDir::new().expect("Failed to create temp dir");
    let test_file = temp_dir.path().join("test.wj");
    fs::write(&test_file, wj_source).unwrap();

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

    assert!(
        output.status.success(),
        "Compilation should succeed, stderr: {}",
        String::from_utf8_lossy(&output.stderr)
    );

    let rs_file = temp_dir.path().join("test.rs");
    let rust_code = fs::read_to_string(&rs_file).expect("Generated Rust file not found");

    // The literal 1.414 in `dist_sq * 1.414` should be f32 (from dist_sq: f32)
    assert!(
        !rust_code.contains("1.414_f64"),
        "1.414 should NOT be f64 when multiplying f32, got:\n{}",
        rust_code
    );

    let cargo_toml = r#"
[package]
name = "test"
version = "0.1.0"
edition = "2021"

[[bin]]
name = "test"
path = "test.rs"

[workspace]
"#;
    let cargo_toml_path = temp_dir.path().join("Cargo.toml");
    fs::write(&cargo_toml_path, cargo_toml).unwrap();

    let rust_build = Command::new("cargo")
        .args(["build", "--release"])
        .current_dir(temp_dir.path())
        .output()
        .expect("Failed to build Rust");

    assert!(
        rust_build.status.success(),
        "Rust compilation should succeed (no f32/f64 mixing), stderr: {}",
        String::from_utf8_lossy(&rust_build.stderr)
    );
}