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

#![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 Test: Method Calls Inside If Blocks Should Use Dot Syntax
// Bug: Method calls inside if blocks without semicolons generate module syntax
// Root Cause: Expression context in if blocks causes incorrect code generation

use std::fs;
use std::process::Command;
use tempfile::TempDir;

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_method_calls_in_if_blocks() {
    let temp_dir = TempDir::new().unwrap();
    let test_file = temp_dir.path().join("test.wj");

    // Write Windjammer code matching scene_serializer pattern
    fs::write(
        &test_file,
        r#"fn test_if_method_calls() -> string {
    let mut json = "{"
    
    let pretty = true
    if pretty {
        json.push_str("\n  ")
    }
    
    json.push_str("test")
    json
}
"#,
    )
    .unwrap();

    // Run wj build with locally built binary
    let wj_binary = std::env::current_exe()
        .unwrap()
        .parent()
        .unwrap()
        .parent()
        .unwrap()
        .join("wj");

    let output = Command::new(&wj_binary)
        .args(["build", test_file.to_str().unwrap(), "--no-cargo"])
        .current_dir(temp_dir.path())
        .output()
        .expect("Failed to run wj build");

    if !output.status.success() {
        eprintln!("STDOUT: {}", String::from_utf8_lossy(&output.stdout));
        eprintln!("STDERR: {}", String::from_utf8_lossy(&output.stderr));
        panic!("wj build failed");
    }

    // Read generated code
    let rust_file = temp_dir.path().join("build/test.rs");
    let rust_code = fs::read_to_string(&rust_file).expect("Failed to read generated Rust");

    println!("Generated Rust code:\n{}", rust_code);

    // THE BUG: Method calls in if blocks generate json::push_str instead of json.push_str
    assert!(
        !rust_code.contains("json::push_str"),
        "BUG FOUND! Generated code uses json::push_str (module syntax) instead of json.push_str (method call). \
         This happens when method calls are inside if blocks without semicolons.\n\
         Generated code:\n{}",
        rust_code
    );

    // Verify correct syntax
    assert!(
        rust_code.contains("json.push_str"),
        "Method calls should use dot syntax"
    );
}