draxl 0.1.1

Agent-native source annotation for semantic program control.
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
144
145
146
147
148
149
150
151
152
153
154

mod support;

use draxl_parser::parse_file;
use draxl_printer::print_file;
use draxl_validate::validate_file;
use support::examples;

#[test]
fn examples_validate_cleanly() {
    for example in examples() {
        let source = std::fs::read_to_string(support::repo_path(example.path))
            .unwrap_or_else(|err| panic!("failed to read {}: {err}", example.path));
        let file = parse_file(&source)
            .unwrap_or_else(|err| panic!("failed to parse {}: {err}", example.path));
        validate_file(&file)
            .unwrap_or_else(|errors| panic!("failed to validate {}: {errors:?}", example.path));
    }
}

#[test]
fn malformed_metadata_prefix_is_rejected() {
    let source = r#"
@
mod demo {}
"#;

    let error = parse_file(source).expect_err("source should fail during parsing");
    assert!(
        error
            .to_string()
            .contains("expected metadata identifier after `@` in Draxl source"),
        "unexpected parse error: {error}"
    );
}

#[test]
fn duplicate_ids_are_reported() {
    let source = r#"
@m1 mod demo {
  @f1[a] fn first() {}
  @f1[b] fn second() {}
}
"#;

    let file = parse_file(source).expect("duplicate ids parse successfully before validation");
    let errors = validate_file(&file).expect_err("duplicate ids should fail validation");
    assert!(
        errors
            .iter()
            .any(|error| error.message.contains("duplicate id `f1`")),
        "expected duplicate id error, found {errors:?}"
    );
}

#[test]
fn missing_rank_in_an_ordered_slot_is_reported() {
    let source = r#"
@m1 mod demo {
  @f1 fn run() {}
}
"#;

    let file = parse_file(source).expect("missing rank parses before validation");
    let errors = validate_file(&file).expect_err("missing rank should fail validation");
    assert!(
        errors
            .iter()
            .any(|error| error.message.contains("missing `rank`")),
        "expected missing rank error, found {errors:?}"
    );
}

#[test]
fn bad_anchor_is_reported() {
    let source = r#"
@m1 mod demo {
  @d1->missing /// Missing anchor target.
  @f1[a] fn run() {}
}
"#;

    let file = parse_file(source).expect("bad anchor parses before validation");
    let errors = validate_file(&file).expect_err("bad anchor should fail validation");
    assert!(
        errors.iter().any(|error| error
            .message
            .contains("must anchor a sibling semantic node")),
        "expected bad anchor error, found {errors:?}"
    );
}

#[test]
fn unsupported_syntax_produces_a_clear_error() {
    let source = r#"
@m1 mod demo {
  @f1[a] fn run<T>() {}
}
"#;

    let error = parse_file(source).expect_err("generic functions are outside the bootstrap subset");
    assert!(
        error
            .to_string()
            .contains("unsupported token in the current Draxl Rust profile"),
        "unexpected unsupported syntax error: {error}"
    );
}

#[test]
fn implicit_doc_attachment_is_valid_and_stable() {
    let source = r#"
@m1 mod demo {
  @d1 /// Runs the job.
  @f2[b] fn second() {}
  @f1[a] fn first() {}
}
"#;

    let file = parse_file(source).expect("source should parse");
    validate_file(&file).expect("implicit doc attachment should validate");
    let formatted = print_file(&file);
    let first = formatted
        .find("@f1[a] fn first()")
        .expect("first function should exist");
    let doc = formatted
        .find("@d1 /// Runs the job.")
        .expect("doc comment should exist");
    let second = formatted
        .find("@f2[b] fn second()")
        .expect("second function should exist");
    assert!(
        first < doc && doc < second,
        "unexpected canonical order:\n{formatted}"
    );
}

#[test]
fn detached_comment_without_anchor_is_rejected() {
    let source = r#"
@m1 mod demo {
  @f1[a] fn run() {}
  @c1 // Detached.
}
"#;

    let file = parse_file(source).expect("detached comment parses before validation");
    let errors = validate_file(&file).expect_err("detached comment should fail validation");
    assert!(
        errors.iter().any(|error| error
            .message
            .contains("needs a following sibling or `->anchor`")),
        "expected detached comment error, found {errors:?}"
    );
}