harn-parser 0.10.53

Parser, AST, and type checker for the Harn programming language
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

use super::*;
use crate::DiagnosticDetails;

#[test]
fn parameterized_test_and_fixture_attributes_are_structurally_validated() {
    let valid = warnings(
        r#"
@test_fixture(scope: file)
fn shared() -> int { return 1 }

@test(cases: [{name: "one", args: [1]}], fixture: shared)
pipeline test_value(_fixture: int, value: int) {}
"#,
    );
    assert!(
        valid.iter().all(|warning| {
            !warning.contains("unknown attribute")
                && !warning.contains("InvalidAttribute")
                && !warning.contains("only applies")
                && !warning.contains("@test")
        }),
        "valid fixture and row metadata should typecheck cleanly: {valid:?}"
    );

    let invalid = warnings(
        r"
@test_fixture(scope: suite, extra: true)
pipeline wrong_target() {}

@test(cases: 1, fixture: 42, typo: [])
fn also_wrong() -> int { return 1 }
",
    );
    assert!(
        invalid
            .iter()
            .any(|warning| warning.contains("only applies to function")),
        "fixture target should be structural: {invalid:?}"
    );
    assert!(
        invalid
            .iter()
            .any(|warning| warning.contains("only applies to pipeline")),
        "test target should be structural: {invalid:?}"
    );
    assert!(
        invalid
            .iter()
            .any(|warning| warning.contains("must be one of [\"file\", \"case\"]")),
        "fixture scope should be an enum-like contract: {invalid:?}"
    );
    assert!(
        invalid
            .iter()
            .any(|warning| warning.contains("unknown `@test` argument `typo`")),
        "test metadata should reject unknown fields: {invalid:?}"
    );
}

#[test]
fn flow_invariant_accepts_only_the_injected_ast_capability() {
    let diagnostics = diagnostics_with_code(
        r#"
@invariant
@deterministic
@archivist(evidence: ["https://example.com/a", "https://example.org/b"], confidence: 0.9, source_date: "2026-08-01")
fn inspect(ast: HarnessAst, slice, _ctx, _repo) -> bool { return true }
"#,
        Code::FlowInvariantAttributeInvalid,
        DiagnosticSeverity::Error,
    );
    assert!(diagnostics.is_empty(), "{diagnostics:#?}");
}

#[test]
fn flow_invariant_rejects_typed_authority_outside_the_runtime_contract() {
    let diagnostics = diagnostics_with_code(
        r#"
type Network = HarnessNet
type AstAlias = HarnessAst

@invariant
@deterministic
@archivist(evidence: ["https://example.com/a", "https://example.org/b"], confidence: 0.9, source_date: "2026-08-01")
fn inspect(
  ast_alias: AstAlias,
  bundle: {ast: HarnessAst, fs: HarnessFs},
  network: Network,
  root: Harness,
  slice,
  _ctx,
  _repo,
) -> bool { return true }
"#,
        Code::FlowInvariantAttributeInvalid,
        DiagnosticSeverity::Error,
    );
    let contracts = diagnostics
        .iter()
        .map(|diagnostic| match diagnostic.details.as_ref() {
            Some(DiagnosticDetails::FlowCapabilityBoundary {
                parameter,
                capabilities,
                allowed,
            }) => (parameter.clone(), capabilities.clone(), allowed.clone()),
            details => panic!("expected typed Flow capability detail, got {details:?}"),
        })
        .collect::<Vec<_>>();
    assert_eq!(
        contracts,
        [
            (
                "ast_alias".to_string(),
                vec!["HarnessAst".to_string()],
                vec!["HarnessAst".to_string()],
            ),
            (
                "bundle".to_string(),
                vec!["HarnessAst".to_string(), "HarnessFs".to_string()],
                vec!["HarnessAst".to_string()],
            ),
            (
                "network".to_string(),
                vec!["HarnessNet".to_string()],
                vec!["HarnessAst".to_string()],
            ),
            (
                "root".to_string(),
                vec!["Harness".to_string()],
                vec!["HarnessAst".to_string()],
            ),
        ]
    );
}

#[test]
fn flow_invariant_boundary_matches_runtime_discovery_kind() {
    let source = r"
@invariant
tool inspect_tool(fs: HarnessFs, slice, _ctx, _repo) -> bool { return true }

@invariant
pipeline inspect_pipeline(network: HarnessNet, slice, _ctx, _repo) {}
";
    let diagnostics = diagnostics_with_code(
        source,
        Code::FlowInvariantAttributeInvalid,
        DiagnosticSeverity::Error,
    );
    assert!(diagnostics.is_empty(), "{diagnostics:#?}");
}