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

// TDD TEST: Bug #2 - format! in temp variable creates &String instead of String
// When format!() is used in a temporary variable and passed to a function/enum expecting String,
// the compiler incorrectly generates `&_temp0` instead of `_temp0`, creating a lifetime issue.

enum AssetError {
    InvalidFormat(string),
    TooLarge(string),
}

fn validate_extension(ext: string) -> Result<(), AssetError> {
    if ext == "png" || ext == "jpg" {
        Ok(())
    } else {
        // CRITICAL PATTERN: format! in expression context, passed to enum variant expecting String
        Err(AssetError::InvalidFormat(format!("Unsupported file extension: {}", ext)))
    }
}

fn validate_size(size: i32, max: i32) -> Result<(), AssetError> {
    if size <= max {
        Ok(())
    } else {
        // CRITICAL PATTERN: format! with multiple args, passed to enum variant expecting String
        Err(AssetError::TooLarge(format!("Asset size {} exceeds max {}", size, max)))
    }
}

pub fn test_format_in_error_enum() {
    // Test 1: Invalid extension
    let result = validate_extension("txt")
    assert(result.is_err(), "Should reject invalid extension")
    
    match result {
        Err(AssetError::InvalidFormat(msg)) => {
            assert(msg.contains("Unsupported"), "Error message should contain 'Unsupported'")
        }
        _ => assert(false, "Wrong error variant")
    }
    
    // Test 2: Size too large
    let result2 = validate_size(1000, 500)
    assert(result2.is_err(), "Should reject large size")
    
    match result2 {
        Err(AssetError::TooLarge(msg)) => {
            assert(msg.contains("exceeds"), "Error message should contain 'exceeds'")
        }
        _ => assert(false, "Wrong error variant")
    }
    
    println("✅ format! in enum variants works correctly")
}

// Test case 2: format! in function argument
fn log_error(message: string) {
    println("ERROR: {}", message)
}

pub fn test_format_in_function_arg() {
    let code = 404
    let path = "/api/users"
    
    // CRITICAL PATTERN: format! directly in function argument
    log_error(format!("HTTP {} for path {}", code, path))
    
    println("✅ format! in function args works correctly")
}

// Test case 3: format! in struct field
struct ErrorReport {
    message: string,
    code: i32,
}

pub fn test_format_in_struct_field() {
    let error_code = 500
    let details = "Database connection failed"
    
    // CRITICAL PATTERN: format! in struct initialization
    let report = ErrorReport {
        message: format!("Error {}: {}", error_code, details),
        code: error_code,
    }
    
    assert(report.message.contains("Error 500"), "Message should contain error code")
    println("✅ format! in struct fields works correctly")
}