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

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

//! TDD: All generated Rust structs MUST have #[repr(C)]
//!
//! Bug: Generated Rust structs lacked #[repr(C)], allowing the Rust compiler
//! to reorder fields for optimization. This corrupted GPU uniform buffer
//! layouts where byte-order matters (to_bytes() serializes in declaration order,
//! but without repr(C) the actual memory layout could differ).
//!
//! Root cause of persistent incorrect material rendering: material colors
//! and lighting parameters were scrambled by field reordering.
//!
//! Fix: The Windjammer compiler now emits #[repr(C)] on ALL struct definitions,
//! guaranteeing field order matches declaration order in memory.

use windjammer::analyzer::Analyzer;
use windjammer::codegen::rust::CodeGenerator;
use windjammer::lexer::Lexer;
use windjammer::parser::Parser;
use windjammer::CompilationTarget;

fn parse_and_generate(source: &str) -> String {
    let mut lexer = Lexer::new(source);
    let tokens = lexer.tokenize_with_locations();
    let parser = Box::leak(Box::new(Parser::new(tokens)));
    let program = parser.parse().unwrap();
    let mut analyzer = Analyzer::new();
    let (analyzed_functions, analyzed_structs, _) = analyzer.analyze_program(&program).unwrap();
    let mut generator = CodeGenerator::new_for_module(analyzed_structs, CompilationTarget::Rust);
    generator.generate_program(&program, &analyzed_functions)
}

#[test]
fn test_simple_struct_has_repr_c() {
    let source = r#"
pub struct Point {
    pub x: f32,
    pub y: f32,
    pub z: f32,
}
"#;
    let output = parse_and_generate(source);
    assert!(
        output.contains("#[repr(C)]"),
        "Generated Rust struct should have #[repr(C)] for guaranteed field order.\nGenerated:\n{}",
        output
    );
    let repr_c_pos = output.find("#[repr(C)]").unwrap();
    let struct_pos = output.find("pub struct Point").unwrap();
    assert!(
        repr_c_pos < struct_pos,
        "#[repr(C)] should appear BEFORE the struct definition"
    );
}

#[test]
fn test_gpu_uniform_struct_has_repr_c() {
    let source = r#"
pub struct LightingUniforms {
    pub sun_dir_x: f32,
    pub sun_dir_y: f32,
    pub sun_dir_z: f32,
    pub _pad0: f32,
    pub sun_color_r: f32,
    pub sun_color_g: f32,
    pub sun_color_b: f32,
    pub sun_intensity: f32,
}
"#;
    let output = parse_and_generate(source);
    assert!(
        output.contains("#[repr(C)]"),
        "GPU uniform struct MUST have #[repr(C)] to prevent field reordering.\nGenerated:\n{}",
        output
    );
}

#[test]
fn test_private_struct_has_repr_c() {
    let source = r#"
struct InternalData {
    pub value: i32,
    pub count: i32,
}
"#;
    let output = parse_and_generate(source);
    assert!(
        output.contains("#[repr(C)]"),
        "Even private structs need #[repr(C)] for consistent layout.\nGenerated:\n{}",
        output
    );
}

#[test]
fn test_struct_with_derive_has_repr_c() {
    let source = r#"
pub struct Color {
    pub r: f32,
    pub g: f32,
    pub b: f32,
    pub a: f32,
}
"#;
    let output = parse_and_generate(source);
    assert!(
        output.contains("#[repr(C)]"),
        "Struct with auto-derive should also have #[repr(C)].\nGenerated:\n{}",
        output
    );
    assert!(
        output.contains("#[derive("),
        "Struct should still have auto-derive traits.\nGenerated:\n{}",
        output
    );
}