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

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

//! Cross-file trait method signatures: multipass build must match impl receivers to inferred trait
//! receivers (E0053 / E0186 regressions).

#[path = "common/integration_test_helpers.rs"]
mod integration_test_helpers;

use integration_test_helpers::MultiFileTest;

/// Trait in one file, impl in another — impl mutates `self`, so Rust must use `&mut self` on both.
#[test]
fn test_trait_method_signature_match_multi_file() {
    let mut test = MultiFileTest::new();

    test.add_file(
        "trait_defs.wj",
        r#"
pub trait MyTrait {
    fn method(self, x: i32)
}
"#,
    );

    test.add_file(
        "holder.wj",
        r#"
use trait_defs::MyTrait

pub struct MyStruct {
    value: i32,
}

impl MyTrait for MyStruct {
    fn method(self, x: i32) {
        self.value = x
    }
}
"#,
    );

    let generated = test.compile().expect("multipass compile");
    let holder = generated.get("holder.rs").expect("holder.rs");
    let defs = generated.get("trait_defs.rs").expect("trait_defs.rs");
    let sig = "fn method(&mut self, x: i32)";
    assert!(
        holder.contains(sig),
        "impl must match inferred trait receiver (E0053 if &self); holder.rs:\n{holder}"
    );
    assert!(
        defs.contains(sig),
        "trait module should agree after cross-file inference; trait_defs.rs:\n{defs}"
    );
}