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 = "parser_tests",
))]

/// TDD Test: Parser Error Line Numbers
///
/// THE WINDJAMMER WAY: Proper tooling before fixing root causes
///
/// This test ensures parser errors include line numbers for debugging.
/// Without line numbers, finding syntax errors in 548-line files is painful.
use std::env;
use std::fs;
use std::path::PathBuf;

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_parser_error_includes_line_number() {
    // Create a test file with a syntax error on a specific line
    let _tmp = tempfile::tempdir().unwrap();
    let test_dir = _tmp.path().join(format!(
        "wj_parser_line_{}_{}",
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos(),
        std::process::id()
    ));

    fs::create_dir_all(&test_dir).unwrap();

    // Windjammer code with syntax error on line 3
    // "let = 10" is invalid - missing pattern before =
    let test_content = r#"
fn main() {
    let = 10
}
"#;

    fs::write(test_dir.join("syntax_error.wj"), test_content).unwrap();

    // Compile the file
    let wj_binary = PathBuf::from(env!("CARGO_BIN_EXE_wj"));
    let output = std::process::Command::new(&wj_binary)
        .current_dir(&test_dir)
        .arg("build")
        .arg("syntax_error.wj")
        .arg("--no-cargo")
        .output()
        .expect("Failed to run wj build");

    let stderr = String::from_utf8_lossy(&output.stderr);
    let stdout = String::from_utf8_lossy(&output.stdout);

    // Cleanup

    // Assert that error message includes line number
    // Should see something like "line 3" or "3:1" or "syntax_error.wj:3"
    let has_line_number = stderr.contains("line 3")
        || stderr.contains(":3:")
        || stderr.contains(":3")
        || stdout.contains("line 3")
        || stdout.contains(":3:")
        || stdout.contains(":3");

    assert!(
        has_line_number,
        "Parser error should include line number.\nSTDOUT:\n{}\nSTDERR:\n{}",
        stdout, stderr
    );

    // Should mention the actual error
    assert!(
        stderr.contains("Expected") || stdout.contains("Expected"),
        "Should have parser error message.\nSTDOUT:\n{}\nSTDERR:\n{}",
        stdout,
        stderr
    );
}

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_parser_error_for_assign_in_pattern_context() {
    // Reproduce the specific "Expected pattern, got Assign" error
    let _tmp2 = tempfile::tempdir().unwrap();
    let test_dir = _tmp2.path().join(format!(
        "wj_pattern_assign_{}_{}",
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos(),
        std::process::id()
    ));

    fs::create_dir_all(&test_dir).unwrap();

    // Minimal reproduction of the pattern/assign issue
    let test_content = r#"
@test
fn test_example() {
    let x = 10
    let result = x + 5   // This might trigger "Expected pattern, got Assign"
    assert!(result == 15)
}
"#;

    fs::write(test_dir.join("pattern_error.wj"), test_content).unwrap();

    let wj_binary = PathBuf::from(env!("CARGO_BIN_EXE_wj"));
    let output = std::process::Command::new(&wj_binary)
        .current_dir(&test_dir)
        .arg("build")
        .arg("pattern_error.wj")
        .arg("--no-cargo")
        .output()
        .expect("Failed to run wj build");

    let stderr = String::from_utf8_lossy(&output.stderr);
    let stdout = String::from_utf8_lossy(&output.stdout);

    // Cleanup

    // If there's an error, it should have a line number
    if stderr.contains("Expected pattern") || stdout.contains("Expected pattern") {
        let has_line_number = stderr.contains("line ")
            || stderr.contains(":")
            || stdout.contains("line ")
            || stdout.contains(":");

        assert!(
            has_line_number,
            "Parser error should include location info.\nSTDOUT:\n{}\nSTDERR:\n{}",
            stdout, stderr
        );
    }
}